@saadnvd1/agent-os 0.3.744 → 0.3.748

package/components/Approvals/NoApprovalsBadge.tsx

@@ -3,20 +3,33 @@
 import { ShieldOff } from "lucide-react";
 import { useApprovalsModeQuery } from "@/data/approvals";
 import { settingsUiActions } from "@/stores/settingsUi";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 
 // On screen for as long as No approvals mode is on; opens its Settings.
+// Shrinks to the icon when the sidebar header is narrow.
 export function NoApprovalsBadge() {
   const { data } = useApprovalsModeQuery();
   if (!data?.on) return null;
   return (
-    <button
-      type="button"
-      onClick={() => settingsUiActions.open("approvals")}
-      title="No approvals mode is on: nothing waits for a person. Open settings."
-      className="flex h-8 shrink-0 items-center gap-1 rounded-md bg-amber-500/20 px-2 text-xs font-medium text-amber-500 ring-1 ring-amber-500/50"
-    >
-      <ShieldOff className="h-3.5 w-3.5" />
-      No approvals
-    </button>
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <button
+          type="button"
+          onClick={() => settingsUiActions.open("approvals")}
+          aria-label="No approvals mode is on. Open settings."
+          className="flex h-11 w-11 shrink-0 items-center justify-center gap-1 rounded-md bg-amber-500/20 text-xs font-medium text-amber-500 ring-1 ring-amber-500/50 md:h-8 md:w-8 @[22rem]:w-auto @[22rem]:px-2 [@media(hover:none)]:md:h-11"
+        >
+          <ShieldOff className="h-3.5 w-3.5" />
+          <span className="hidden @[22rem]:inline">No approvals</span>
+        </button>
+      </TooltipTrigger>
+      <TooltipContent>
+        No approvals mode is on: nothing waits for a person. Open settings.
+      </TooltipContent>
+    </Tooltip>
   );
 }

package/components/Away/AwayToggle.tsx

@@ -39,16 +39,16 @@ export function AwayToggle() {
   return (
     <ADropdownMenu
       minWidth="220px"
+      tooltip={
+        away
+          ? `Away ${until}`
+          : "Away: let the orchestrators follow work through"
+      }
       trigger={
         <Button
           variant="ghost"
           size="icon-sm"
           aria-label={away ? `Away ${until}` : "Away"}
-          title={
-            away
-              ? `Away ${until}`
-              : "Away: let the orchestrators follow work through"
-          }
           disabled={setAway.isPending}
           className={cn(
             "relative h-11 w-11 md:h-8 md:w-8 [@media(hover:none)]:md:h-11 [@media(hover:none)]:md:w-11",

package/components/Chat/ChatPanel.tsx

@@ -56,7 +56,8 @@ import { McpServers } from "./McpServers";
 import { ChatSessionId } from "./session";
 import { ArtifactCard } from "./Artifact";
 import { PlanCard } from "./PlanCard";
-import { ChatIdle } from "./idle";
+import { ChatIdle, RetryTurn } from "./idle";
+import { RETRY_TEXT } from "@/lib/chat/turn-end";
 import { ContextMeter } from "./ContextMeter";
 import { SetupCard } from "./SetupCard";
 import { UserTurn } from "./EventRow";
@@ -631,6 +632,11 @@ export function ChatPanel({
   // Another conversation starts without the last one's find.
   useEffect(() => closeFind, [sessionId, closeFind]);
   const idle = !running && connected;
+  const lastEndId = items.findLast((i) => i.kind === "turn_end")?.id ?? null;
+  const retryTurn = useMemo(
+    () => ({ id: lastEndId, retry: () => send(RETRY_TEXT) }),
+    [lastEndId, send]
+  );
   const actions: ItemActions = useMemo(
     () => ({
       respond,
@@ -691,7 +697,9 @@ export function ChatPanel({
                   </div>
                   <ChatSessionId.Provider value={sessionId}>
                     <ChatIdle.Provider value={idle}>
-                      <TimelineRows blocks={blocks} actions={actions} />
+                      <RetryTurn.Provider value={retryTurn}>
+                        <TimelineRows blocks={blocks} actions={actions} />
+                      </RetryTurn.Provider>
                     </ChatIdle.Provider>
                   </ChatSessionId.Provider>
                   {pending.map((p) => (

package/components/Chat/Messages.test.ts

@@ -2,6 +2,7 @@ import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it, vi } from "vitest";
 import { AssistantMessage, TurnEnd, UserMessage } from "./Messages";
+import { ChatIdle, RetryTurn } from "./idle";
 
 const item = {
   id: "a1",
@@ -131,3 +132,35 @@ describe("TurnEnd steps", () => {
     expect(html).toContain("Stopped · 4 of 5 steps done, 1 failed, 1 not run");
   });
 });
+
+describe("TurnEnd retry", () => {
+  const end = (reason: string, id = "e") =>
+    ({
+      id,
+      kind: "turn_end",
+      ended: { reason, notice: "It stalled." },
+    }) as never;
+  const html = (item: never, retry: { id: string | null }, idle = true) =>
+    renderToStaticMarkup(
+      createElement(
+        ChatIdle.Provider,
+        { value: idle },
+        createElement(
+          RetryTurn.Provider,
+          { value: { ...retry, retry: () => {} } },
+          createElement(TurnEnd, { item })
+        )
+      )
+    );
+
+  it("offers Retry on the latest stalled end while idle", () => {
+    expect(html(end("stalled"), { id: "e" })).toContain(">Retry<");
+    expect(html(end("compaction_empty"), { id: "e" })).toContain(">Retry<");
+  });
+
+  it("does not on an older end, a running chat, or an ending retry can't fix", () => {
+    expect(html(end("stalled"), { id: "later" })).not.toContain("Retry");
+    expect(html(end("stalled"), { id: "e" }, false)).not.toContain("Retry");
+    expect(html(end("length"), { id: "e" })).not.toContain("Retry");
+  });
+});

package/components/Chat/Messages.tsx

@@ -2,6 +2,8 @@
 
 import type { StepCounts } from "@/lib/chat/tool-outcome";
 import { memo } from "react";
+import { retryableEnd } from "@/lib/chat/turn-end";
+import { useChatIdle, useRetryTurn } from "./idle";
 import { useSnapshot } from "valtio";
 import {
   Check,
@@ -398,6 +400,10 @@ export function TurnEnd({
 }) {
   const secs = item.durationMs ? Math.round(item.durationMs / 1000) : null;
   const early = !item.interrupted && item.ended;
+  const idle = useChatIdle();
+  const retryTurn = useRetryTurn();
+  const canRetry =
+    !!early && idle && retryTurn.id === item.id && retryableEnd(early.reason);
   const label = item.interrupted
     ? "Stopped"
     : early
@@ -420,6 +426,15 @@ export function TurnEnd({
               finish reason: {item.finishReason}
             </span>
           )}
+          {canRetry && (
+            <button
+              type="button"
+              onClick={retryTurn.retry}
+              className="hover:bg-foreground/[0.06] mt-2 block min-h-11 rounded-md border border-current/30 px-3 text-sm font-medium md:min-h-8"
+            >
+              Retry
+            </button>
+          )}
         </div>
       )}
       <div className="group text-muted-foreground/60 flex items-center gap-3 font-mono text-[11px]">

package/components/Chat/idle.ts

@@ -7,3 +7,12 @@ import { createContext, useContext } from "react";
 // re-renders those buttons and not every row of a long conversation.
 export const ChatIdle = createContext(true);
 export const useChatIdle = () => useContext(ChatIdle);
+
+// The latest turn's end and what retrying it does: only that end offers
+// Retry, and only while the chat is idle. A context so the one turn ending
+// doesn't re-render every row.
+export const RetryTurn = createContext<{
+  id: string | null;
+  retry: () => void;
+}>({ id: null, retry: () => {} });
+export const useRetryTurn = () => useContext(RetryTurn);

package/components/SessionList/MachineSwitcher.tsx

@@ -32,7 +32,7 @@ export function MachineSwitcher() {
           type="button"
           aria-label={`Machine: ${current ? machineLabel(current) : "All machines"}`}
           className={cn(
-            "border-border/70 text-muted-foreground hover:text-foreground hover:bg-foreground/[0.04] flex h-11 max-w-full min-w-0 items-center gap-1.5 rounded-lg border px-2.5 text-xs md:h-8",
+            "text-muted-foreground hover:text-foreground bg-card flex min-h-11 max-w-full min-w-0 items-center gap-1.5 rounded-xl border border-transparent px-3 text-sm shadow-xs md:min-h-9 [@media(hover:none)]:md:min-h-11",
             current && "border-primary/40 bg-primary/10 text-primary"
           )}
         >

package/components/SessionList/ProjectFilter.tsx

@@ -25,7 +25,7 @@ export function ProjectFilter({
         <button
           type="button"
           className={cn(
-            "bg-card flex min-h-11 max-w-[7.5rem] shrink items-center gap-1 rounded-xl px-3 text-sm shadow-xs md:min-h-9 [@media(hover:none)]:md:min-h-11",
+            "bg-card flex min-h-11 max-w-full min-w-0 shrink items-center gap-1 rounded-xl px-3 text-sm shadow-xs md:min-h-9 [@media(hover:none)]:md:min-h-11",
             current && "text-primary"
           )}
         >

package/components/SessionList/SidebarHeader.tsx

@@ -67,8 +67,8 @@ export function SidebarHeader(props: SidebarHeaderProps) {
   const workspaceId = props.workspace?.id ?? null;
   const schedules = useSchedulesGlance(workspaceId);
   return (
-    <div className="flex flex-wrap items-center gap-x-1 px-3 pt-3 pb-2">
-      <div className="flex min-w-[9.5rem] flex-1 items-center">
+    <div className="@container flex flex-wrap items-center gap-x-1 gap-y-2 px-3 pt-3 pb-2">
+      <div className="flex min-w-[9.5rem] flex-1 basis-[9.5rem] items-center">
         <WorkspaceSwitcher
           workspaces={props.workspaces}
           current={props.workspace}
@@ -190,7 +190,7 @@ export function SidebarHeader(props: SidebarHeaderProps) {
           ]}
         />
       </div>
-      <div className="w-full empty:hidden">
+      <div className="flex w-full min-w-0 empty:hidden">
         <MachineSwitcher />
       </div>
     </div>

package/components/SessionList/SidebarSearch.tsx

@@ -7,7 +7,7 @@ import { sidebarUiActions } from "@/stores/sidebarUi";
 // sessions too.
 export function SidebarSearch({ query }: { query: string }) {
   return (
-    <label className="bg-card text-muted-foreground focus-within:ring-primary/40 flex min-h-11 min-w-[6rem] flex-1 items-center gap-2 rounded-xl px-3 shadow-xs focus-within:ring-2 md:min-h-9 [@media(hover:none)]:md:min-h-11">
+    <label className="bg-card text-muted-foreground focus-within:ring-primary/40 flex min-h-11 min-w-[6rem] flex-[1_1_8rem] items-center gap-2 rounded-xl px-3 shadow-xs focus-within:ring-2 md:min-h-9 [@media(hover:none)]:md:min-h-11">
       <Search className="h-3.5 w-3.5 shrink-0" />
       <input
         type="search"

package/components/SessionList/index.tsx

@@ -168,7 +168,7 @@ export function SessionList({
         }
         pinControls={pinControls}
       />
-      <div className="flex gap-2 px-3 pb-2">
+      <div className="flex flex-wrap gap-2 px-3 pb-2">
         <SidebarSearch query={ui.query} />
         <ProjectFilter
           projects={data.workspaceProjects}

package/components/Settings/NoApprovalsSection.test.ts

@@ -38,6 +38,7 @@ vi.mock("@/data/approvals", () => ({
   }),
 }));
 
+const { TooltipProvider } = await import("@/components/ui/tooltip");
 const { NoApprovalsSection } = await import("./NoApprovalsSection");
 const { NoApprovalsBadge } =
   await import("@/components/Approvals/NoApprovalsBadge");
@@ -112,10 +113,12 @@ describe("the No approvals toggle", () => {
 
 describe("the badge", () => {
   it("shows only while the mode is on", () => {
-    render(createElement(NoApprovalsBadge));
+    const badge = () =>
+      createElement(TooltipProvider, null, createElement(NoApprovalsBadge));
+    render(badge());
     expect(host.textContent).toBe("");
     state.on = true;
-    render(createElement(NoApprovalsBadge));
+    render(badge());
     expect(host.textContent).toContain("No approvals");
   });
 });

package/lib/chat/demo.ts

@@ -11,6 +11,7 @@ import type {
   ChatClientMessage,
   ChatServerMessage,
   ChatState,
+  Compacting,
   ModelWait,
 } from "./events";
 import { demoConversation } from "./drivers/demo";
@@ -31,7 +32,10 @@ const sends = new Map<string, number>();
 
 // What a demo chat is doing, for a watcher that connects mid-turn (the stored
 // items alone would show a running step as stopped).
-const live = new Map<string, { state: ChatState; wait: ModelWait | null }>();
+const live = new Map<
+  string,
+  { state: ChatState; wait: ModelWait | null; compacting: Compacting | null }
+>();
 
 /** The demo chat's running turn, or null with none. */
 export function demoLive(sessionId: string) {
@@ -46,6 +50,18 @@ function conversation(sessionId: string): ChatConversation {
   let tracker = new ModelWaitTracker();
   void (async () => {
     for await (const e of c.events) {
+      if (e.type === "compacting") {
+        // The tokens before are the scripted prompt's (drivers/demo-script).
+        const compacting = e.active
+          ? { since: Date.now(), before: 48_200 }
+          : null;
+        const state = live.get(sessionId);
+        if (state) state.compacting = compacting;
+        tracker.on({ type: "compacting", compacting } as WorkerEvent);
+        emit(sessionId, { type: "compacting", compacting });
+        emit(sessionId, { type: "model_wait", wait: tracker.wait });
+        continue;
+      }
       // Each turn follows its own waits, whatever the last one left.
       if (e.type === "state" && e.state === "running")
         tracker = new ModelWaitTracker();
@@ -53,7 +69,12 @@ function conversation(sessionId: string): ChatConversation {
         emit(sessionId, { type: "model_wait", wait: tracker.wait });
       if (e.type === "state") {
         if (e.state === "idle") live.delete(sessionId);
-        else live.set(sessionId, { state: e.state, wait: tracker.wait });
+        else
+          live.set(sessionId, {
+            state: e.state,
+            wait: tracker.wait,
+            compacting: null,
+          });
       }
       const state = live.get(sessionId);
       if (state) state.wait = tracker.wait;

package/lib/chat/drivers/demo-script.ts

@@ -4,12 +4,17 @@
  * model, a retry) for a set time, then finishes. Demo only: the demo driver
  * is the one place that reads it (AGENTOS_DEMO=1; no real session gets here).
  *
- *     demo: running turn [step|wait|retry] [hold=<seconds>]
+ *     demo: running turn [step|wait|retry|compact|stalled|empty] [hold=<seconds>]
+ *
+ * compact holds a compaction; stalled and empty end the turn the way a stalled
+ * model request and an empty reply after compaction do (with a Retry).
  */
 
-import type { DriverEvent } from "../events";
+import type { DriverEvent, TurnEndReason } from "../events";
+import { COMPACTION_EMPTY_NOTICE, stalledNotice } from "./turn-outcome";
 
-export type DemoPhase = "step" | "wait" | "retry";
+export type DemoPhase =
+  "step" | "wait" | "retry" | "compact" | "stalled" | "empty";
 
 export interface DemoScript {
   // Hold only this state; none runs all three, one after the other.
@@ -19,7 +24,8 @@ export interface DemoScript {
 
 export const DEFAULT_HOLD_S = 30;
 export const MAX_HOLD_S = 120;
-const TRIGGER = /^demo: running turn(?: (step|wait|retry))?(?: hold=(\d+))?$/;
+const TRIGGER =
+  /^demo: running turn(?: (step|wait|retry|compact|stalled|empty))?(?: hold=(\d+))?$/;
 
 export function parseDemoScript(text: string): DemoScript | null {
   const m = TRIGGER.exec(text.trim());
@@ -99,6 +105,13 @@ async function runningStep(run: ScriptRun, id: string, holdMs: number) {
   });
 }
 
+// A compaction of a big context, held, then done.
+async function compacting(run: ScriptRun, holdMs: number) {
+  run.push({ type: "compacting", active: true });
+  await hold(run, holdMs);
+  run.push({ type: "compacting", active: false });
+}
+
 export async function runDemoScript(
   script: DemoScript,
   run: ScriptRun,
@@ -108,6 +121,13 @@ export async function runDemoScript(
   const phases: DemoPhase[] = script.phase
     ? [script.phase]
     : ["step", "wait", "retry"];
+  // The end of a turn that stopped short, after one finished step.
+  const ending: { reason: TurnEndReason; notice: string } | undefined =
+    script.phase === "stalled"
+      ? { reason: "stalled", notice: stalledNotice(22 * 60_000, false) }
+      : script.phase === "empty"
+        ? { reason: "compaction_empty", notice: COMPACTION_EMPTY_NOTICE }
+        : undefined;
   run.push({ type: "state", state: "running" });
   run.push({ type: "turn_start" });
   run.push({
@@ -124,6 +144,11 @@ export async function runDemoScript(
     if (run.stopped()) break;
     if (phase === "step")
       await runningStep(run, `demo-t-${runId}`, script.holdMs);
+    else if (phase === "stalled" || phase === "empty") {
+      await runningStep(run, `demo-t-${runId}`, 0);
+      if (phase === "empty") await compacting(run, script.holdMs);
+      else await hold(run, script.holdMs);
+    } else if (phase === "compact") await compacting(run, script.holdMs);
     else {
       if (phase === "retry")
         run.push({
@@ -141,6 +166,7 @@ export async function runDemoScript(
       kind: "turn_end",
       durationMs: Date.now() - started,
       interrupted: run.stopped() || undefined,
+      ended: run.stopped() ? undefined : ending,
       createdAt: Date.now(),
     },
   });

package/lib/chat/drivers/opencode-config.ts

@@ -13,6 +13,11 @@ type P = Record<string, unknown>;
 // that never answers still ends the request.
 export const HEADER_TIMEOUT_MS = 1_200_000;
 
+// How long a turn may wait on the model with no sign of life before AgentOS
+// stops it. Just past one header timeout: OpenCode would retry the same
+// stall up to five more times, hours on a local model.
+export const STALL_MS = HEADER_TIMEOUT_MS + 120_000;
+
 const isObject = (v: unknown): v is P =>
   !!v && typeof v === "object" && !Array.isArray(v);
 

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

@@ -2,7 +2,13 @@ import { randomUUID } from "crypto";
 import type { DriverEvent, UsageTotals } from "../events";
 import { openCodeTool } from "./opencode-rules";
 import { TurnItems } from "./turn-items";
-import { logTurnEnd, needsSummary, turnOutcome } from "./turn-outcome";
+import {
+  logTurnEnd,
+  needsSummary,
+  stalledNotice,
+  turnOutcome,
+  type TurnEnded,
+} from "./turn-outcome";
 import { retryNotice, TurnRetry, type RetryDecision } from "./transient-retry";
 
 type P = Record<string, unknown>;
@@ -12,6 +18,9 @@ const num = (v: unknown) => Number(v) || 0;
 // A prompt this big (tokens) is worth compacting before the last retry.
 const HEAVY_TOKENS = 16_000;
 
+// Events that show the session is alive; a retry notice is not one.
+const PROGRESS = /^(message\.|session\.(status|compacted|error)|todo\.)/;
+
 const TODO = new Set(["pending", "in_progress", "completed"]);
 
 // OpenCode's event stream as chat items, for one session (its subagents'
@@ -63,6 +72,15 @@ export class OpenCodeMapper {
   lastInputTokens = 0;
   // Compacting between retries makes the session busy and idle: not a turn.
   private holding = false;
+  // OpenCode is compacting the context (its summary request is out).
+  private compacting = false;
+  // A compaction ran in this turn; the messages that are its summary.
+  private compacted = false;
+  private summaries = new Set<string>();
+  // Tool calls not finished yet: the turn waits on them, not on the model.
+  private open = new Set<string>();
+  // When the session last did anything: the stall watchdog's clock.
+  private progressAt = Date.now();
 
   constructor(
     private sessionId: () => string | null,
@@ -84,12 +102,26 @@ export class OpenCodeMapper {
       this.agentRetried = false;
     }
     this.admitted = false;
+    this.progressAt = Date.now();
     this.items.startTurn();
   }
 
+  // How long the turn has waited on the model without a sign of life; 0
+  // while it isn't waiting on one (a tool runs, a retry is queued).
+  silentMs(now = Date.now()): number {
+    if (!this.items.inTurn || this.holding || this.retrying || this.open.size)
+      return 0;
+    return Math.max(0, now - this.progressAt);
+  }
+
   map(e: P): void {
     const p = (e.properties ?? {}) as P;
     if (p.sessionID && p.sessionID !== this.sessionId()) return;
+    if (
+      PROGRESS.test(e.type as string) &&
+      !(e.type === "session.status" && str((p.status as P)?.type) === "retry")
+    )
+      this.progressAt = Date.now();
     switch (e.type) {
       case "session.status": {
         const type = str((p.status as P)?.type);
@@ -113,6 +145,8 @@ export class OpenCodeMapper {
       case "session.error":
         return this.failed(p.error as P | undefined);
       case "session.compacted":
+        this.compacted = true;
+        this.setCompacting(false);
         return this.emit({
           type: "item",
           item: { id: randomUUID(), kind: "compacted", createdAt: Date.now() },
@@ -144,7 +178,15 @@ export class OpenCodeMapper {
     this.current.add(id);
     this.roles.set(id, str(info.role));
     if (info.role !== "assistant") return;
-    if (this.last.id !== id)
+    const summary =
+      info.summary === true ||
+      info.mode === "compaction" ||
+      info.agent === "compaction";
+    if (summary) {
+      this.summaries.add(id);
+      this.setCompacting(!(info.time as P)?.completed && !info.error);
+    }
+    if (!summary && this.last.id !== id)
       this.last = {
         id,
         finish: "",
@@ -153,9 +195,11 @@ export class OpenCodeMapper {
         text: new Map(),
         calls: new Set(),
       };
-    this.last.finish = str(info.finish) || this.last.finish;
-    this.last.provider = str(info.providerID) || this.last.provider;
-    this.last.model = str(info.modelID) || this.last.model;
+    if (!summary) {
+      this.last.finish = str(info.finish) || this.last.finish;
+      this.last.provider = str(info.providerID) || this.last.provider;
+      this.last.model = str(info.modelID) || this.last.model;
+    }
     if (info.error) this.failed(info.error as P);
     if (!(info.time as P)?.completed || this.counted.has(id)) return;
     this.counted.add(id);
@@ -181,8 +225,12 @@ export class OpenCodeMapper {
     const id = str(part.id);
     if (this.past.has(id) || this.past.has(str(part.messageID))) return;
     this.current.add(id);
+    // A compaction starts as a part of the message that asks for it.
+    if (part.type === "compaction") return this.setCompacting(true);
     // Only the agent's own messages: the prompt comes back as a part too.
     if (this.roles.get(str(part.messageID)) !== "assistant") return;
+    // The summary is the agent's memory, not part of the reply.
+    if (this.summaries.has(str(part.messageID))) return;
     if (part.type === "text" || part.type === "reasoning") {
       if (part.synthetic || part.ignored) return;
       const kind = part.type === "text" ? "assistant" : "reasoning";
@@ -200,6 +248,11 @@ export class OpenCodeMapper {
     }
     if (part.type === "tool") {
       this.toolIds.add(id);
+      const done = ["completed", "error"].includes(
+        str((part.state as P | undefined)?.status)
+      );
+      if (done) this.open.delete(id);
+      else this.open.add(id);
       if (this.last.id === str(part.messageID)) this.last.calls.add(id);
       this.tool(id, part);
     }
@@ -234,8 +287,15 @@ export class OpenCodeMapper {
       this.items.toolDone(id, "error", str(state.error), start);
   }
 
+  private setCompacting(on: boolean): void {
+    if (on === this.compacting) return;
+    this.compacting = on;
+    this.emit({ type: "compacting", active: on });
+  }
+
   private failed(error: P | undefined): void {
     if (!error) return;
+    this.setCompacting(false);
     if (error.name === "MessageAbortedError") this.aborted = true;
     else
       this.error =
@@ -268,6 +328,9 @@ export class OpenCodeMapper {
     for (const id of this.current) this.past.add(id);
     this.current.clear();
     this.parts.clear();
+    this.open.clear();
+    this.summaries.clear();
+    this.compacted = false;
   }
 
   // A failed turn is waiting for its retry to go out.
@@ -287,6 +350,7 @@ export class OpenCodeMapper {
 
   private idle(): void {
     if (this.holding || !this.admitted || !this.items.inTurn) return;
+    this.setCompacting(false);
     if (this.error && !this.aborted && this.retryTurn()) return;
     this.emit({ type: "usage", totals: { ...this.totals } });
     const text = [...this.last.text.values()].join("\n");
@@ -308,18 +372,26 @@ export class OpenCodeMapper {
       console.info("[chat] asked the model for its results summary");
       return;
     }
-    const ended =
-      this.aborted || !this.last.id
-        ? undefined
-        : turnOutcome({
-            finishReason: this.last.finish,
-            text,
-            toolCalls: this.last.calls.size,
-            error: this.error ?? undefined,
-            retries: this.retry.tried,
-            agentRetried: this.agentRetried,
-            summary: this.items.summary(),
-          });
+    const ended = this.aborted
+      ? undefined
+      : turnOutcome({
+          finishReason: this.last.finish,
+          text,
+          toolCalls: this.last.calls.size,
+          compacted: this.compacted,
+          toolsDone: /tool/i.test(this.last.finish) && !this.open.size,
+          error: this.error ?? undefined,
+          retries: this.retry.tried,
+          agentRetried: this.agentRetried,
+          summary: this.items.summary(),
+        });
+    this.finish(ended, text);
+    this.clearTurn();
+    this.nudged = this.nudgeDue = false;
+  }
+
+  // The turn is over: the end told, then the state reset.
+  private finish(ended: TurnEnded | undefined, text: string): void {
     if (ended)
       logTurnEnd({
         driver: "opencode",
@@ -335,6 +407,21 @@ export class OpenCodeMapper {
       finishReason: this.last.finish || undefined,
       ended,
     });
+  }
+
+  // The model stayed silent past the limit: the driver stops the session and
+  // the turn ends here, with what it got through kept.
+  stalled(ms: number): void {
+    if (!this.items.inTurn) return;
+    const compacting = this.compacting;
+    this.setCompacting(false);
+    this.retrying = false;
+    this.emit({ type: "usage", totals: { ...this.totals } });
+    const ended: TurnEnded = {
+      reason: "stalled",
+      notice: stalledNotice(ms, compacting),
+    };
+    this.finish(ended, "");
     this.clearTurn();
     this.nudged = this.nudgeDue = false;
   }

package/lib/chat/drivers/opencode.ts

@@ -8,7 +8,7 @@ import { openCodeRules } from "./opencode-rules";
 import { OpenCodeServer } from "./opencode-server";
 import { OpenCodeApprovals } from "./opencode-approvals";
 import { RESULTS_BRIEF, SUMMARY_NUDGE } from "./turn-outcome";
-import { openCodeConfigContent } from "./opencode-config";
+import { openCodeConfigContent, STALL_MS } from "./opencode-config";
 import { writeOpenCodeGuard } from "./opencode-plugin";
 import { typescriptPath } from "./edit-guard";
 import { continuePrompt, type RetryDecision } from "./transient-retry";
@@ -44,6 +44,9 @@ function conversationEnv(
   }
 }
 
+// How often a waiting turn is checked for silence.
+const WATCH_MS = 30_000;
+
 // How long a prompt may go without the session turning busy before the
 // turn is checked on.
 const ADMIT_MS = 15_000;
@@ -142,6 +145,20 @@ export const openCodeDriver: ChatDriver = {
     const held: { text: string; images?: ChatImage[] }[] = [];
     const stream = new AbortController();
     let closed = false;
+    // A turn silent for STALL_MS (an env override is for tests only) is
+    // stopped: OpenCode's own retries could wait for hours.
+    const stallMs = Number(process.env.AGENTOS_OPENCODE_STALL_MS) || STALL_MS;
+    const watchdog = setInterval(
+      () => {
+        const silent = mapper.silentMs();
+        if (silent < stallMs) return;
+        cancelRetry();
+        mapper.stalled(silent);
+        void abort();
+      },
+      Math.min(WATCH_MS, stallMs / 2)
+    );
+    watchdog.unref();
 
     const fail = (error: Error) => mapper.items.error(error.message);
     const ours = (id: unknown) => id === sessionId || children.has(str(id));
@@ -286,6 +303,7 @@ export const openCodeDriver: ChatDriver = {
     function close() {
       if (closed) return;
       closed = true;
+      clearInterval(watchdog);
       cancelRetry();
       approvals.pending.expireAll();
       stream.abort();

package/lib/chat/drivers/turn-outcome.ts

@@ -80,10 +80,26 @@ export function failureReport(o: {
   return `The model's server ${kind === "timeout" ? "timed out" : "kept failing"} (${why})${tries}. ${done} Not finished: the model's next reply, so the task is incomplete. Send "continue" to resume; the finished steps are kept.`;
 }
 
+export const COMPACTION_EMPTY_NOTICE =
+  'The model returned nothing after compaction, so the task is incomplete. Retry sends "continue"; the finished steps are kept.';
+
+export const CUT_OFF_NOTICE =
+  'The turn stopped right after a tool step, before the model replied, so the task may be incomplete. Retry sends "continue"; the finished steps are kept.';
+
+// Said when a model request got no answer for the whole stall limit.
+export function stalledNotice(ms: number, compacting: boolean): string {
+  const min = Math.max(1, Math.round(ms / 60_000));
+  return `${compacting ? "The model didn't finish compacting the context" : "Model request stalled"}: no response for ${plural(min, "minute")}, so AgentOS stopped waiting. The finished steps are kept. Retry sends "continue".`;
+}
+
 export function turnOutcome(r: {
   finishReason?: string;
   text: string;
   toolCalls: number;
+  // A compaction ran in this turn.
+  compacted?: boolean;
+  // Every tool call of the turn has finished.
+  toolsDone?: boolean;
   error?: string;
   retries?: number;
   agentRetried?: boolean;
@@ -107,7 +123,12 @@ export function turnOutcome(r: {
           })
         : "The model's server returned an error, shown above.",
     };
-  if (r.toolCalls > 0) return undefined;
+  if (r.toolCalls > 0)
+    return r.toolsDone
+      ? { reason: "cut_off", notice: CUT_OFF_NOTICE }
+      : undefined;
+  if (r.compacted && !r.text.trim())
+    return { reason: "compaction_empty", notice: COMPACTION_EMPTY_NOTICE };
   if (hasToolMarkup(r.text))
     return {
       reason: "parse_failure",

package/lib/chat/events.ts

@@ -151,7 +151,16 @@ interface Base {
 }
 
 export type TurnEndReason =
-  "no_tool_call" | "length" | "parse_failure" | "empty" | "error";
+  | "no_tool_call"
+  | "length"
+  | "parse_failure"
+  | "empty"
+  | "error"
+  // The model gave no reply for too long, or none after a compaction, or
+  // the turn stopped right after a tool step.
+  | "stalled"
+  | "compaction_empty"
+  | "cut_off";
 
 export type ChatItem =
   | (Base & {

package/lib/chat/group.ts

@@ -1,8 +1,16 @@
-import type { ChatItem } from "./events";
+import type { ChatItem, TurnEndReason } from "./events";
 import { readingOrder } from "./reading-order";
 import { stepCounts, type StepCounts } from "./tool-outcome";
 import { eventTurnAt, type EventTurn } from "./turns";
 
+// Ends that stop a turn mid-task: they show how many steps got done.
+const CUT_SHORT = new Set<TurnEndReason>([
+  "error",
+  "stalled",
+  "compaction_empty",
+  "cut_off",
+]);
+
 export type ToolItem = Extract<ChatItem, { kind: "tool" }>;
 export type UndoItem = Extract<ChatItem, { kind: "undo" }>;
 
@@ -99,7 +107,8 @@ export function groupTimeline(
       flush();
       const cut =
         item.kind === "turn_end" &&
-        (item.interrupted || item.ended?.reason === "error");
+        (item.interrupted ||
+          (item.ended !== undefined && CUT_SHORT.has(item.ended.reason)));
       blocks.push(
         cut && turnTools.length
           ? { type: "item", item, steps: stepCounts(turnTools) }

package/lib/chat/progress.ts

@@ -7,6 +7,8 @@ export type Phase = "planning" | "coding" | "testing" | "error";
 
 // A wait on one model call this long gets a hint that it may be normal.
 export const LONG_WAIT_MS = 2 * 60_000;
+export const LONG_COMPACT_HINT =
+  "Compacting a large context on a local model can take minutes.";
 export const LONG_WAIT_HINT =
   "Still waiting on the model; large prompts on local models can take minutes";
 
@@ -118,6 +120,8 @@ export function currentActivity(
       compacting: true,
       kind: "compacting",
       steps: 0,
+      hint:
+        now - compacting.since > LONG_WAIT_MS ? LONG_COMPACT_HINT : undefined,
     };
   const lastUser = items.findLast((i) => i.kind === "user" && !i.midTurn);
   const tools = turnTools(items);

package/lib/chat/runner-watch.ts

@@ -44,7 +44,7 @@ export function watchChat(sessionId: string, listener: Listener): () => void {
     hasMore: page.hasMore,
     tasks: present(sessionId, tasks),
     state: live?.state ?? demo?.state ?? "idle",
-    compacting: live?.compacting ?? null,
+    compacting: live?.compacting ?? demo?.compacting ?? null,
     modelWait: live?.modelWait ?? demo?.wait ?? null,
     queue: listQueue(sessionId),
     suggestion: getSession(sessionId).chat_suggestion ?? null,

package/lib/chat/turn-end.ts

@@ -0,0 +1,16 @@
+import type { TurnEndReason } from "./events";
+
+// The ends a Retry button can resume: the model's side failed or went quiet.
+const RETRYABLE: TurnEndReason[] = [
+  "error",
+  "empty",
+  "stalled",
+  "compaction_empty",
+  "cut_off",
+];
+
+export const retryableEnd = (reason: TurnEndReason) =>
+  RETRYABLE.includes(reason);
+
+// What Retry sends: the steps that ran stay, the model carries on.
+export const RETRY_TEXT = "continue";

package/lib/updates/check.ts

@@ -163,6 +163,38 @@ export async function compare(deps: CheckDeps): Promise<CheckResult> {
   };
 }
 
+/**
+ * A cached answer was worked out against whatever HEAD was then. If the
+ * checkout has since moved (a pull by hand, a switch to another branch) and
+ * now contains the latest commit, there's nothing to update to.
+ */
+export async function reconcile(
+  check: CheckResult | null,
+  deps: Pick<CheckDeps, "git">
+): Promise<CheckResult | null> {
+  if (!check?.available || !check.latest) return check;
+  try {
+    const head = (await deps.git(["rev-parse", "HEAD"])).trim();
+    if (head === check.current?.sha) return check;
+    const has = await deps
+      .git(["merge-base", "--is-ancestor", check.latest.sha, "HEAD"])
+      .then(
+        () => true,
+        () => false
+      );
+    return has
+      ? {
+          ...check,
+          available: false,
+          behind: 0,
+          current: { version: check.latest.version, sha: head },
+        }
+      : check;
+  } catch {
+    return check;
+  }
+}
+
 let memo: CheckResult | null = null;
 let inflight: Promise<CheckResult> | null = null;
 

package/lib/updates/view.ts

@@ -2,7 +2,7 @@
 // whether the caller may start an update.
 
 import { isActivePhase, type UpdateView } from "./banner";
-import { cachedCheck, checkForUpdate } from "./check";
+import { cachedCheck, checkForUpdate, reconcile } from "./check";
 import {
   preflight,
   readLog,
@@ -40,6 +40,7 @@ export async function updateView(
   )
     check = (await checkForUpdate({ force: true, always: true }, deps.check))
       .result;
+  check = await reconcile(check, deps.check);
   // The log can carry paths and remote URLs; only a device that may update sees it.
   const run =
     stored && (stored.phase === "failed" || stored.phase === "built")

package/package.json

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