@saadnvd1/agent-os 0.3.483 → 0.3.485

package/README.md

@@ -363,6 +363,24 @@ fired `mid_turn` or `between_turns`, and the context before and after), so cost
 menu, dialog or the command list is open (those close first). On a phone the
 Stop button does the same. A stopped turn keeps what it wrote.
 
+Stop ends the turn even while the model is still thinking, before any tool
+call: the turn is interrupted, and if it hasn't ended within a few seconds the
+agent process is ended and restarted for the next message (not if the chat is
+waiting on an approval or question, or if a new message has started a new
+turn meanwhile). The conversation and
+worktree are kept, and whatever is sent next (yours, another agent's, the
+orchestrator's) runs as the next turn, never queued behind the stopped one.
+The UI, the orchestrator's `stop` tool and `aos stop` all take this one path
+and report "stopped" or a real error.
+
+A turn that has produced nothing (no token, tool call or result) for 8 minutes
+shows as **Stalled** in the session list, and its workspace's orchestrator gets
+one event naming the session, how long it has been silent and its last action.
+It fires once per stall and starts over when the session does something. A
+foreground tool call gets four times as long, and a session waiting on a
+background command it started isn't flagged. Set the time (2 to 120 minutes, 0 for off)
+in Settings → Workspaces → Stall alerts.
+
 The access picker under the composer sets what the agent may do on its own:
 **Ask first** (an approval card in the chat for anything not already allowed),
 **Accept edits** (edits files, asks before other commands) or **Full access**
@@ -852,6 +870,7 @@ aos schedule run <name>           # run a schedule now
 aos schedule add --session <s> --every 30m "prompt"  # check in on a session
 aos notify "text"                 # push a message to your phone
 aos heavy -- npm test             # run it now; says first what else heavy is running
+aos stop <session>                # stop its turn now; the next message runs as a new turn
 aos done <session>                # finished: merge through the gates, archive
 aos done --all-idle               # the same for every idle session around you
 aos docs [query]                  # LumifyHub pages, when the workspace is linked

package/app/api/bus/stop/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from "next/server";
+import { resolveSession } from "@/lib/bus";
+import { getDoneTarget } from "@/lib/done";
+import { inScope, scopeOf } from "@/lib/done/bulk";
+import { stopSession } from "@/lib/sessions/stop";
+
+// `aos stop <session>`, from inside a session: ends the turn in progress
+// (or the terminal agent) and keeps the conversation and worktree. Reaches
+// only the caller's workspace (or its project when it has none).
+export async function POST(request: NextRequest) {
+  try {
+    const { from = null, session } = await request.json();
+    if (typeof from !== "string" || !from)
+      throw new Error("aos stop runs from inside an AgentOS session");
+    const caller = getDoneTarget(from);
+    const target = resolveSession(String(session ?? ""));
+    if (!inScope(scopeOf(caller), target))
+      throw new Error(
+        `${target.name} isn't in ${caller.name}'s workspace or project; aos stop reaches only those`
+      );
+    return NextResponse.json({ summary: await stopSession(target) });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/app/api/stall/route.ts

@@ -0,0 +1,18 @@
+import { NextRequest, NextResponse } from "next/server";
+import { setStallMinutes, stallMinutes } from "@/lib/chat/stall";
+
+// How long a chat turn may be silent before it's flagged stalled and its
+// workspace's orchestrator is told (lib/chat/stall); 0 for never.
+export async function GET() {
+  return NextResponse.json({ minutes: stallMinutes() });
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    const body = await request.json();
+    return NextResponse.json({ minutes: setStallMinutes(body.minutes) });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/components/SessionList/RowParts.tsx

@@ -41,6 +41,12 @@ export function RowBadge({ row }: { row: SidebarRow }) {
       </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">
+        Stalled
+      </span>
+    );
   if (row.unread) return <UnreadDot />;
   return null;
 }

package/components/SessionList/SessionList.types.ts

@@ -9,6 +9,7 @@ export interface SessionStatus {
   asks?: number;
   need?: SessionNeed | null;
   unread?: boolean;
+  stalled?: boolean;
 }
 
 export interface SessionListProps {

package/components/Workspaces/StallForm.tsx

@@ -0,0 +1,101 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Switch } from "@/components/ui/switch";
+import { useStallQuery, useUpdateStall } from "@/data/stall";
+import {
+  DEFAULT_STALL_MINUTES,
+  MAX_STALL_MINUTES,
+  MIN_STALL_MINUTES,
+} from "@/lib/chat/stall-limits";
+
+// How long a turn may produce nothing before it's flagged stalled and the
+// workspace's orchestrator is told: app-wide.
+export function StallForm() {
+  const { data, isPending, isError, error } = useStallQuery();
+  if (isPending)
+    return <div className="bg-muted/40 h-24 animate-pulse rounded-lg" />;
+  if (isError)
+    return <p className="text-destructive text-sm">{error.message}</p>;
+  return <Form key={data.minutes} saved={data.minutes} />;
+}
+
+function Form({ saved }: { saved: number }) {
+  const update = useUpdateStall();
+  const [on, setOn] = useState(saved > 0);
+  const [text, setText] = useState(
+    String(saved > 0 ? saved : DEFAULT_STALL_MINUTES)
+  );
+  const n = Number(text);
+  const valid =
+    Number.isInteger(n) && n >= MIN_STALL_MINUTES && n <= MAX_STALL_MINUTES;
+  const minutes = on ? n : 0;
+  const error =
+    on && !valid
+      ? `Between ${MIN_STALL_MINUTES} and ${MAX_STALL_MINUTES} minutes`
+      : null;
+  const dirty = !error && minutes !== saved;
+
+  return (
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        if (error) return;
+        update.mutate(minutes, {
+          onSuccess: () => toast.success("Stall alert saved"),
+          onError: (err) => toast.error(err.message),
+        });
+      }}
+      className="bg-muted/40 space-y-3 rounded-lg px-3 py-3"
+    >
+      <h3 className="text-sm font-medium">Stalled turns</h3>
+      <p className="text-muted-foreground text-sm">
+        A turn that produces nothing for this long (no text, tool call or
+        result) shows as stalled, and the workspace&apos;s orchestrator is told
+        once. A long command that is still printing, or a background command the
+        agent is waiting on, isn&apos;t a stall.
+      </p>
+      <label className="flex min-h-11 items-center justify-between gap-3 text-sm md:min-h-9">
+        Flag stalled turns
+        <Switch
+          checked={on}
+          onCheckedChange={setOn}
+          aria-label="Flag stalled turns"
+        />
+      </label>
+      {on && (
+        <label className="flex items-center justify-between gap-3 text-sm">
+          <span className="text-muted-foreground">After</span>
+          <span className="flex items-center gap-2">
+            <Input
+              type="number"
+              inputMode="numeric"
+              min={MIN_STALL_MINUTES}
+              max={MAX_STALL_MINUTES}
+              value={text}
+              onChange={(e) => setText(e.target.value)}
+              aria-label="Stall threshold, minutes"
+              aria-invalid={!!error}
+              className="h-11 w-24 text-base sm:h-9 md:text-sm"
+            />
+            <span className="text-muted-foreground">minutes</span>
+          </span>
+        </label>
+      )}
+      {error && <p className="text-destructive text-xs">{error}</p>}
+      <div className="flex justify-end">
+        <Button
+          type="submit"
+          size="sm"
+          className="h-11 sm:h-8"
+          disabled={!!error || !dirty || update.isPending}
+        >
+          Save
+        </Button>
+      </div>
+    </form>
+  );
+}

package/components/Workspaces/WorkspaceSettings.tsx

@@ -5,6 +5,7 @@ import { useUpdateWorkspace, useWorkspacesQuery } from "@/data/workspaces";
 import { TaskLimitForm } from "./TaskLimitForm";
 import { RulesForm } from "./RulesForm";
 import { FreshStartForm } from "./FreshStartForm";
+import { StallForm } from "./StallForm";
 import { WorkspaceModelsForm } from "./WorkspaceModelsForm";
 import { AwayWindowForm } from "@/components/Away/AwayWindowForm";
 
@@ -53,6 +54,7 @@ export function WorkspaceSettings() {
         </section>
       ))}
       <FreshStartForm />
+      <StallForm />
       <AwayWindowForm />
     </div>
   );

package/data/stall/index.ts

@@ -0,0 +1,33 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+// How long a turn may be silent before it's stalled (lib/chat/stall).
+export const stallKeys = { all: ["stall"] as const };
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `Request failed (${res.status})`);
+  return data;
+}
+
+export function useStallQuery() {
+  return useQuery({
+    queryKey: stallKeys.all,
+    queryFn: async () => json<{ minutes: number }>(await fetch("/api/stall")),
+    staleTime: 60000,
+  });
+}
+
+export function useUpdateStall() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (minutes: number) =>
+      json<{ minutes: number }>(
+        await fetch("/api/stall", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ minutes }),
+        })
+      ),
+    onSuccess: (data) => queryClient.setQueryData(stallKeys.all, data),
+  });
+}

package/lib/chat/activity.ts

@@ -1,23 +1,48 @@
-import type { ChatState } from "./events";
+import type { ChatItem, ChatState } from "./events";
 import { formatElapsed } from "./elapsed";
 import { registry, type Live } from "./registry";
+import { stallThresholdMs } from "./stall";
 import { listItems } from "./store";
 import type { WorkerEvent } from "./worker/protocol";
 
+const lastWhat = (i: ChatItem): string =>
+  i.kind === "tool"
+    ? i.status === "running"
+      ? i.title
+      : `finished ${i.title}`
+    : i.kind === "assistant"
+      ? "writing a reply"
+      : i.kind === "reasoning"
+        ? "thinking"
+        : i.kind === "user"
+          ? "your message"
+          : i.kind;
+
 // Keeps a conversation's "what it's doing now" current from its events.
 export function track(live: Live, e: WorkerEvent): void {
   const a = live.activity;
   if (e.type === "state") {
-    if (e.state === "running" && !a.turnStartedAt) a.turnStartedAt = Date.now();
+    if (e.state === "running" && !a.turnStartedAt) {
+      a.turnStartedAt = Date.now();
+      a.lastAt = a.turnStartedAt;
+      a.lastWhat = "starting the turn";
+    }
     if (e.state === "idle") {
       a.turnStartedAt = undefined;
+      a.lastAt = a.lastWhat = undefined;
       a.tools.clear();
     }
   } else if (e.type === "item" && e.item.kind === "turn_end") {
     // A queued message starts the next turn with no idle in between.
     a.turnStartedAt = undefined;
+    a.lastAt = a.lastWhat = undefined;
     a.tools.clear();
-  } else if (e.type === "item" && e.item.kind === "tool") {
+  } else if (e.type === "item" || e.type === "delta") {
+    a.lastAt = Date.now();
+    a.lastWhat = e.type === "delta" ? "writing" : lastWhat(e.item);
+  }
+  if (e.type === "item" && e.item.kind === "user") a.sends = (a.sends ?? 0) + 1;
+  if (e.type === "item" && e.item.kind === "tool") {
     if (e.item.status === "running")
       a.tools.set(e.item.id, { label: e.item.title, since: e.item.createdAt });
     else a.tools.delete(e.item.id);
@@ -35,6 +60,11 @@ export function restoreActivity(sessionId: string, state: ChatState) {
     activity.turnStartedAt = items.findLast(
       (i) => i.kind === "user"
     )?.createdAt;
+  if (state !== "idle") {
+    const last = items.at(-1);
+    activity.lastAt = last?.createdAt ?? activity.turnStartedAt;
+    activity.lastWhat = last ? lastWhat(last) : undefined;
+  }
   for (const i of items) {
     if (i.kind === "tool" && i.status === "running" && state !== "idle")
       activity.tools.set(i.id, { label: i.title, since: i.createdAt });
@@ -44,11 +74,50 @@ export function restoreActivity(sessionId: string, state: ChatState) {
   return activity;
 }
 
+export interface Stall {
+  silentMs: number;
+  // What it last did.
+  last: string;
+  // When that was: one stall per value, so a condition keyed on it fires
+  // once and a new one starts only after activity resumes.
+  since: number;
+}
+
+// A turn that has produced nothing (no token, item or result) for the
+// threshold. Never one waiting on an answer, nor one with a background task
+// running: a command it started can legitimately be quiet.
+const TOOL_STALL_FACTOR = 4;
+
+export function stallOf(
+  live: Live,
+  now: number,
+  thresholdMs: number
+): Stall | null {
+  const a = live.activity;
+  if (live.state !== "running" || 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.
+  if (a.tools.size > 0) thresholdMs *= TOOL_STALL_FACTOR;
+  const since = a.lastAt ?? a.turnStartedAt;
+  if (!since || now - since < thresholdMs) return null;
+  return { silentMs: now - since, last: a.lastWhat ?? "unknown", since };
+}
+
+// Whether a chat on this machine is stalled now, by the app-wide threshold.
+export function chatStall(sessionId: string): Stall | null {
+  const live = registry.live.get(sessionId);
+  return live ? stallOf(live, Date.now(), stallThresholdMs()) : null;
+}
+
 // 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
-): { label: string; since?: number; background: number } | null {
+export function chatActivity(sessionId: string): {
+  label: string;
+  since?: number;
+  background: number;
+  stalled?: Stall;
+} | null {
   const live = registry.live.get(sessionId);
   if (!live) return null;
   const a = live.activity;
@@ -57,6 +126,9 @@ export function chatActivity(
     return { label: "Needs your answer", background };
   if (live.state !== "running")
     return background ? { label: "Idle", background } : null;
+  const stalled = stallOf(live, Date.now(), stallThresholdMs()) ?? undefined;
+  if (stalled)
+    return { label: "Stalled", since: stalled.since, background, stalled };
   const tool = [...a.tools.values()].at(-1);
   return tool
     ? { label: tool.label, since: tool.since, background }
@@ -71,6 +143,8 @@ export function chatActivityLine(sessionId: string): string | null {
     ? `${a.background} running in background`
     : "";
   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];
   if (a.since) parts.push(formatElapsed(Date.now() - a.since));
   if (background) parts.push(background);

package/lib/chat/events.ts

@@ -354,7 +354,7 @@ export type ChatClientMessage =
   // `during`: the user message whose turn was running when it was tapped.
   | { type: "queue_send_now"; id: string; during?: string }
   | { type: "files"; reqId: string; query: string }
-  | { type: "interrupt" }
+  | { type: "interrupt"; hard?: boolean }
   | { type: "set_model"; model: string }
   | { type: "set_access"; access: ChatAccess }
   | { type: "set_plan"; plan: boolean }

package/lib/chat/registry.ts

@@ -34,6 +34,13 @@ export interface Live {
 
 export interface ChatActivity {
   turnStartedAt?: number;
+  // When the turn last produced anything (a token, an item, a tool result)
+  // and what that was; unset between turns. Silence from here is a stall.
+  lastAt?: number;
+  lastWhat?: string;
+  // Messages the user side has sent this conversation: a change while a stop
+  // waits means a new turn began, which the stop must leave alone.
+  sends?: number;
   // Running tool calls by id: their label and when they started.
   tools: Map<string, { label: string; since: number }>;
   // Running background tasks (not housekeeping ones).

package/lib/chat/runner.ts

@@ -697,6 +697,8 @@ export async function undoChat(
   reply({ type: "undone", from, text: target.text });
 }
 
+// A plain Esc: ends the turn the way the agent would, and leaves a queue
+// behind it alone. Stop (./stop stopChatTurn) is the one that must end it.
 export async function interruptChat(sessionId: string): Promise<void> {
   registry.live.get(sessionId)?.worker.command({ type: "interrupt" });
 }

package/lib/chat/socket.ts

@@ -16,7 +16,6 @@ import {
   chatToolBody,
   deleteQueuedChat,
   editQueuedChat,
-  interruptChat,
   moveQueuedChat,
   refreshCapabilities,
   respondChat,
@@ -29,6 +28,7 @@ import {
   undoChat,
   watchChat,
 } from "./runner";
+import { stopChatTurn } from "./stop";
 import { clientSend } from "./client-send";
 import { searchChat } from "./search";
 import { DEMO_CHAT_READS, handleDemoChat } from "./demo";
@@ -175,7 +175,7 @@ function onChatMessage(
         .catch(() => [])
         .then(answer)
     );
-  } else if (msg.type === "interrupt") run(interruptChat(sessionId));
+  } else if (msg.type === "interrupt") run(stopChatTurn(sessionId));
   else if (msg.type === "set_model") run(setChatModel(sessionId, msg.model));
   else if (msg.type === "set_access") run(setChatAccess(sessionId, msg.access));
   else if (msg.type === "set_plan") run(setChatPlan(sessionId, !!msg.plan));

package/lib/chat/stall-limits.ts

@@ -0,0 +1,5 @@
+// The range the stall alert may take (lib/chat/stall), shared with the
+// settings form.
+export const DEFAULT_STALL_MINUTES = 8;
+export const MIN_STALL_MINUTES = 2;
+export const MAX_STALL_MINUTES = 120;

package/lib/chat/stall.ts

@@ -0,0 +1,50 @@
+/**
+ * Stall alerts: a chat turn silent for this long (no token, tool call or
+ * result) is flagged "stalled" in the UI and reported once to its workspace's
+ * orchestrator (lib/orchestrator/conditions). App-wide, in Settings →
+ * Workspaces. 0 is off.
+ */
+
+import { db } from "../db";
+import {
+  DEFAULT_STALL_MINUTES,
+  MAX_STALL_MINUTES,
+  MIN_STALL_MINUTES,
+} from "./stall-limits";
+
+export const STALL_KEY = "chat.stall_minutes";
+
+export function stallMinutes(): number {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(STALL_KEY) as { value: string } | undefined;
+  const n = row ? Number(row.value) : DEFAULT_STALL_MINUTES;
+  return Number.isInteger(n) && n >= 0 ? n : DEFAULT_STALL_MINUTES;
+}
+
+export const stallThresholdMs = () => stallMinutes() * 60_000;
+
+// 0 (off) or a whole number of minutes in range. Throws a plain message
+// otherwise.
+export function checkStallMinutes(value: unknown): number {
+  if (value === 0) return 0;
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < MIN_STALL_MINUTES ||
+    value > MAX_STALL_MINUTES
+  )
+    throw new Error(
+      `The stall alert is off or between ${MIN_STALL_MINUTES} and ${MAX_STALL_MINUTES} minutes`
+    );
+  return value;
+}
+
+export function setStallMinutes(value: unknown): number {
+  const minutes = checkStallMinutes(value);
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(STALL_KEY, String(minutes));
+  return minutes;
+}

package/lib/chat/stop.ts

@@ -68,3 +68,70 @@ export async function stopChatAtTurnEnd(
     await sleep(POLL_MS);
   }
 }
+
+export type TurnStop =
+  | { stopped: true; killed: boolean }
+  | { stopped: false; reason: string };
+
+export interface TurnStopOptions {
+  // How long the turn gets to end after the interrupt before its agent is
+  // killed.
+  graceMs?: number;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+const TURN_POLL_MS = 250;
+// Idle has to hold this long: the CLI answers an interruption with a short
+// turn of its own, which the host cuts short, and that must be over too.
+const SETTLE_MS = 2500;
+
+// The one way every caller (the stop button, the orchestrator's stop, aos
+// stop, a restack) ends the turn in progress. The turn is interrupted, even
+// while the model is thinking before any tool call; if it hasn't ended within
+// the grace period the agent is killed. The conversation and worktree are
+// kept, and the next message runs as the next turn.
+export async function stopChatTurn(
+  sessionId: string,
+  { graceMs = 8000, sleep = defaultSleep }: TurnStopOptions = {}
+): Promise<TurnStop> {
+  let state;
+  try {
+    await registry.connecting.get(sessionId);
+    state = await chatStateNow(sessionId);
+  } catch {
+    return {
+      stopped: false,
+      reason: "its chat worker is running but isn't answering",
+    };
+  }
+  if (!state || state === "idle") return { stopped: true, killed: false };
+  // Its agent is asked a question: killing it would lose the card.
+  if (state === "waiting")
+    return {
+      stopped: false,
+      reason:
+        "it's waiting on an approval or question in its chat; answer or dismiss that first",
+    };
+  const sendsAtStop = registry.live.get(sessionId)?.activity.sends ?? 0;
+  registry.live
+    .get(sessionId)
+    ?.worker.command({ type: "interrupt", hard: true });
+  let idleFor = 0;
+  for (let waited = 0; waited < graceMs + SETTLE_MS; waited += TURN_POLL_MS) {
+    await sleep(TURN_POLL_MS);
+    // A message sent meanwhile has started a new turn: not ours to kill.
+    if ((registry.live.get(sessionId)?.activity.sends ?? 0) !== sendsAtStop)
+      return { stopped: true, killed: false };
+    const now = await chatStateNow(sessionId).catch(
+      () => "unreachable" as const
+    );
+    if (now === null || now === "idle") {
+      idleFor += TURN_POLL_MS;
+      if (idleFor >= SETTLE_MS) return { stopped: true, killed: false };
+    } else idleFor = 0;
+    if (waited >= graceMs && idleFor === 0) break;
+  }
+  stopChat(sessionId);
+  await waitForExit(sessionId);
+  return { stopped: true, killed: true };
+}

package/lib/chat/worker/host.ts

@@ -50,6 +50,10 @@ import type { WorkerCommand, WorkerEvent } from "./protocol";
 // still counts as part of the stop: the agent starts what it queued the
 // moment a turn ends.
 const AFTER_STOP_MS = 2000;
+// After a hard stop (Stop, the orchestrator's stop, aos stop), how long the
+// agent's own wind-down turn is cut short and any sender's message reads as
+// the next turn.
+const HARD_STOP_MS = 30_000;
 
 // How long a retiring worker waits, once at rest with nothing queued, for
 // the agent's guess at the next message before it goes.
@@ -104,6 +108,7 @@ export class ChatHost {
   // should read next.
   private stopping: "turn" | "after" | null = null;
   private stoppedAt = 0;
+  private hardStopAt = 0;
   // On an older build than the server's (a "retire"): it closes at the next
   // turn boundary, once the agent holds no message it hasn't run and runs
   // no background work, so a current worker resumes the conversation.
@@ -327,6 +332,10 @@ export class ChatHost {
           this.settleCompactedLine(e.context.usedTokens);
           this.refreshIfFull(e.context.usedTokens);
         } else if (e.type === "turn_start") {
+          // The agent starting a turn of its own right after a hard stop
+          // (the CLI winds down with a reply to the interruption) is cut
+          // short, so what's sent next isn't queued behind it.
+          if (this.hardStopped()) void this.conversation.interrupt();
           this.turnsStarted++;
           this.turnStartedAt ??= Date.now();
           if (this.behind) this.behind--;
@@ -437,6 +446,7 @@ export class ChatHost {
   ): void {
     this.sent.add(m.id);
     this.currentTurn = m.id;
+    this.hardStopAt = 0;
     if (this.busy()) this.behind++;
     // Sent now, it stops the running turn, which still ends after this.
     if (!this.busy()) now = false;
@@ -562,9 +572,7 @@ export class ChatHost {
         // Another agent's message doesn't speak for the reader.
         if (
           this.stopping &&
-          !cmd.from &&
-          !cmd.peer &&
-          !cmd.origin &&
+          (this.hardStopped() || (!cmd.from && !cmd.peer && !cmd.origin)) &&
           this.busy() &&
           !listQueue(this.session.id).length
         ) {
@@ -624,6 +632,12 @@ export class ChatHost {
         return;
       case "interrupt":
         await this.modeChange.catch(() => {});
+        if (cmd.hard) {
+          this.hardStopAt = Date.now();
+          this.behind = 0;
+          this.stopping = "turn";
+          return this.conversation.interrupt();
+        }
         if (!this.busy()) return this.conversation.interrupt();
         // What's queued goes on once the turn stops: it goes with the stop,
         // so it's what the agent reads next.
@@ -663,6 +677,10 @@ export class ChatHost {
     }
   }
 
+  private hardStopped(): boolean {
+    return this.hardStopAt > 0 && Date.now() - this.hardStopAt < HARD_STOP_MS;
+  }
+
   // A retiring worker goes once it's at a turn boundary: no turn running,
   // no message handed to the agent still to run, no background work (it
   // lives in the agent, and would be lost). With nothing queued it first

package/lib/chat/worker/protocol.ts

@@ -46,7 +46,8 @@ export type WorkerCommand =
   // Send the queue if no turn is running; a running one sends it as it ends.
   | { type: "drain" }
   | { type: "files"; reqId: string; query: string }
-  | { type: "interrupt" }
+  // hard: a stop that must end the turn (and the agent's wind-down after it).
+  | { type: "interrupt"; hard?: boolean }
   | { type: "set_model"; model: string }
   | { type: "set_access"; access: ChatAccess }
   | { type: "set_plan"; plan: boolean }

package/lib/orchestrator/act.ts

@@ -6,9 +6,9 @@
 
 import { parseOverride, type ModelOverride } from "../models/resolve";
 import { sendMessage } from "../bus";
-import { chatState, interruptChat } from "../chat/runner";
+import { chatState } from "../chat/runner";
+import { stopSession } from "../sessions/stop";
 import { isRemoteHost } from "../hosts";
-import { endTmuxSession } from "../tmux/end";
 import { spawnSession } from "../agents/spawn";
 import {
   DEFAULT_START_VIEW,
@@ -226,11 +226,5 @@ export async function done(workspaceId: string, ref: string): Promise<string> {
 // Stops the agent and keeps everything else: a chat's turn is interrupted,
 // a terminal's tmux session ends. Its worktree and branch stay.
 export async function stop(workspaceId: string, ref: string): Promise<string> {
-  const s = findWorkspaceSession(workspaceId, ref);
-  if (s.view === "chat") {
-    await interruptChat(s.id);
-    return `Stopped ${s.name}'s turn.`;
-  }
-  await endTmuxSession(s.host_id, s.tmux_name);
-  return `Stopped ${s.name}: its agent is ended, its worktree and branch are kept.`;
+  return stopSession(findWorkspaceSession(workspaceId, ref));
 }

package/lib/orchestrator/armed.ts

@@ -123,6 +123,7 @@ function fingerprint(
   return [
     head,
     pr.checks,
+    pr.mergeable,
     (f.task?.ciSettleIn ?? 0) > 0,
     getCheck(task.id, head, "review")?.status,
     getCheck(task.id, head, "scope")?.status,

package/lib/orchestrator/conditions.ts

@@ -89,6 +89,13 @@ function sessionConditions(
         ciKey(pr),
         `${who}: ${ciWord(pr)}${pr.checks === "pass" ? " and settled" : ""}`
       );
+    // Mergeable for a long while with no check in a repository that has CI:
+    // CI probably wasn't triggered. News once per head, never an escalation.
+    if (pr.checks === "none" && f.task?.ciSilentMs !== undefined)
+      add(
+        `ci-silent:${pr.number}:${pr.head ?? ""}`,
+        `${who}: PR #${pr.number} at ${(pr.head ?? "").slice(0, 7)} has been mergeable for ${Math.floor(f.task.ciSilentMs / 60000)}m with no CI check registered; CI may not have been triggered on this head`
+      );
   }
 
   const blocked = f.task?.blocked ?? null;
@@ -109,6 +116,17 @@ function sessionConditions(
       true
     );
 
+  // Keyed on when it last did anything, so it is one event per stall and
+  // anything the session does after it makes the next stall a new one.
+  if (f.stalled)
+    add(
+      `stalled:${f.stalled.since}`,
+      `${who}: stalled: no output for ${Math.floor(f.stalled.silentMs / 60000)}m mid-turn (last: ${untrusted(f.name, f.stalled.last)}). Read it; stop it if it's stuck.`,
+      false,
+      false,
+      true
+    );
+
   // A quick change is the orchestrator's own: nothing to tell it.
   const shouldPR = (!!f.task || !!f.branch) && !f.quick;
   const finished = !!f.task && isFinished(f.task.state);

package/lib/orchestrator/describe.ts

@@ -17,7 +17,9 @@ export function ciWord(pr: TaskPR): string {
       ? `CI failed: ${untrusted("CI", pr.failing)}`
       : "CI failed";
   if (pr.checks === "pending") return "CI pending";
-  return "no CI";
+  return pr.mergeable === "CONFLICTING"
+    ? "conflicts with its base, no CI yet"
+    : "no checks yet";
 }
 
 export const shortId = (id: string) => id.slice(0, 8);

package/lib/orchestrator/external-gates.ts

@@ -75,6 +75,8 @@ export async function judgeExternal(
           checkCount: pr.checkCount ?? 0,
           committedAt: await commitTime(ext.repo, sha),
         }),
+        mergeable: pr.mergeable,
+        baseName: ext.base,
         review,
         blocked: null,
         waitingOn: null,

package/lib/orchestrator/external-pr.ts

@@ -63,7 +63,7 @@ export type GateTarget =
   | { kind: "external"; pr: ExternalPR };
 
 const FIELDS =
-  "number,url,state,headRefOid,headRefName,baseRefName,isDraft,labels,isCrossRepository,statusCheckRollup,body,title";
+  "number,url,state,headRefOid,headRefName,baseRefName,isDraft,labels,isCrossRepository,statusCheckRollup,body,title,mergeable";
 
 interface ViewedPR extends ListedPR {
   baseRefName?: string;

package/lib/orchestrator/facts.ts

@@ -10,7 +10,7 @@ import { statusDetector } from "../status-detector";
 import { hostLink } from "../hosts/remote-api";
 import { peerStatus } from "../hosts/peer-sessions";
 import { chatState } from "../chat/runner";
-import { chatActivityLine } from "../chat/activity";
+import { chatActivityLine, chatStall, type Stall } from "../chat/activity";
 import { lastUserTask } from "../chat/store";
 import { needsYou } from "../needs-you";
 import { programSummary } from "../program-status/store";
@@ -18,7 +18,8 @@ import { sessionRowInfo } from "../session-meta";
 import { taskView, type TaskPR, type TaskState } from "../tasks";
 import { storedPR } from "../tasks/session";
 import { commitTime, repoOf } from "./repo";
-import { ciSettleIn } from "./task-state";
+import { CHECKLESS_MS, checklessFor, ciSettleIn } from "./task-state";
+import { repoHasCI } from "./repo-ci";
 
 export type FactStatus = "running" | "waiting" | "idle" | "dead";
 
@@ -32,6 +33,8 @@ export interface SessionFacts {
   // Really stopped on an answer: a chat's approval or question card, or a
   // terminal at its prompt. A chat that merely finished doesn't count.
   needsInput: boolean;
+  // A chat turn silent past the stall threshold (lib/chat/stall).
+  stalled?: Stall | null;
   // Last sign of life, in ms.
   lastActive: number;
   // Work that should end in a PR: a task, or a session on its own branch.
@@ -45,6 +48,9 @@ export interface SessionFacts {
     // With CI green on the PR's head: seconds until it counts as settled
     // (task-state.ts), when the CI-green event goes out.
     ciSettleIn?: number;
+    // Set once a mergeable head in a repository with CI has had no checks
+    // for CHECKLESS_MS (task-state.ts): ms it has been without.
+    ciSilentMs?: number;
   } | null;
   stack: {
     id: string;
@@ -211,6 +217,20 @@ export async function settleIn(
   });
 }
 
+async function silentFor(
+  s: Session,
+  pr: TaskPR | null
+): Promise<number | undefined> {
+  if (!pr) return;
+  const silent = checklessFor(s.id, pr);
+  if (silent === undefined || silent < CHECKLESS_MS) return;
+  const ci = await repoHasCI(
+    repoOf(s),
+    `origin/${pr.base ?? s.base_branch ?? "main"}`
+  ).catch(() => "unknown");
+  return ci === "yes" ? silent : undefined;
+}
+
 // A finished task's state is in the database: no gh call for it.
 async function taskFacts(
   workspaceId: string,
@@ -228,6 +248,7 @@ async function taskFacts(
     pr: view.pr,
     blocked: view.blocked,
     ciSettleIn: await settleIn(workspaceId, s, view.pr),
+    ciSilentMs: await silentFor(s, view.pr),
   };
 }
 
@@ -249,6 +270,8 @@ export async function sessionFacts(
         status,
         activity,
         needsInput,
+        stalled:
+          s.view === "chat" && !hostLink(s.host_id) ? chatStall(s.id) : null,
         lastActive: Math.max(
           sqliteMs(s.updated_at),
           statusDetector.getTimestamp(s.tmux_name) * 1000,

package/lib/orchestrator/gates.ts

@@ -1,7 +1,8 @@
 /**
  * The merge gates, ported from dispatch orchestrate. Each one passes, waits
  * (not ready yet: CI running or settling, no review of this commit yet),
- * fails, or goes straight to Saad (no CI at all). Only a failure counts
+ * fails, or goes straight to Saad (the repository has no CI at all, never
+ * just a head with no checks). Only a failure counts
  * against the task, and a gate failing again on a different commit goes to
  * Saad instead of being retried. A failure counts once per task, gate and
  * head commit, whichever path judged it (the armed watcher, CI finishing,
@@ -12,9 +13,10 @@
 
 import { db } from "../db";
 import type { CodeReviewGate } from "../tasks/code-review";
-import type { ChecksVerdict } from "../tasks/state";
+import type { ChecksVerdict, TaskPR } from "../tasks/state";
 import type { CheckRow } from "./checks";
 import { APPROVAL_GATES, mergeApprovalsOn } from "./merge-approvals";
+import type { RepoCI } from "./repo-ci";
 import { untrusted } from "./untrusted";
 
 export type GateName =
@@ -37,6 +39,11 @@ export interface GateInput {
   failing?: string | null;
   // Seconds until CI on this commit counts as settled (tasks/task-state).
   settleIn: number;
+  // GitHub's word on merging the PR into its base, and that base's name.
+  mergeable?: TaskPR["mergeable"];
+  baseName?: string | null;
+  // Whether the repository has CI; only read when the head has no checks.
+  repoCI?: RepoCI;
   review: CheckRow | null;
   // A BLOCKED: line, or an approval or question the agent is waiting on.
   blocked: string | null;
@@ -68,22 +75,48 @@ function ciGate(i: GateInput): GateOutcome {
       state: "fail",
       reason: `CI failed on ${at}${i.failing ? ` (${untrusted("CI", i.failing)})` : ""}`,
     };
+  if (i.checks === "none") return noChecks(i, at);
   if (i.settleIn > 0)
     return {
       gate,
       state: "wait",
-      reason:
-        i.checks === "none"
-          ? `no CI checks have registered on ${at} yet (looking again in ${i.settleIn}s)`
-          : `CI is green on ${at} but settling: ${i.settleIn}s more with no new check`,
+      reason: `CI is green on ${at} but settling: ${i.settleIn}s more with no new check`,
     };
-  if (i.checks === "none")
+  return { gate, state: "pass" };
+}
+
+// A head with no checks. Only a repository with no CI at all has nothing to
+// gate on; in one with CI the head is not yet, whatever the reason.
+function noChecks(i: GateInput, at: string): GateOutcome {
+  const gate = "ci";
+  const wait = (reason: string): GateOutcome => ({
+    gate,
+    state: "wait",
+    reason,
+  });
+  if (i.mergeable === "CONFLICTING")
+    return wait(
+      `PR conflicts with ${i.baseName ?? "its base"}; CI can't run on ${at} until it's rebased`
+    );
+  if (i.settleIn > 0)
+    return wait(
+      `no CI checks have registered on ${at} yet (looking again in ${i.settleIn}s)`
+    );
+  if (i.repoCI === "no")
     return {
       gate,
       state: "escalate",
-      reason: `no CI ran on ${at}: this repository has no checks to gate a merge on`,
+      reason: `no CI ran on ${at}: this repository has no checks to gate a merge on (no workflow files, and no check has run on its default branch or recent PRs)`,
     };
-  return { gate, state: "pass" };
+  if (i.repoCI === "yes")
+    return wait(
+      i.mergeable === "UNKNOWN"
+        ? `no CI checks on ${at} yet: GitHub is still working out whether it merges cleanly`
+        : `no CI checks on ${at} yet: CI hasn't been triggered on this head`
+    );
+  return wait(
+    `no CI checks on ${at}, and whether this repository has CI couldn't be read; looking again`
+  );
 }
 
 // A stored check of this exact commit: missing, running or broken waits.

package/lib/orchestrator/repo-ci.ts

@@ -0,0 +1,104 @@
+/**
+ * Whether a repository has CI at all, decided from the repository and never
+ * from one head: workflow files on the base, else any check or status that
+ * ever ran on the default branch or the recent PRs. A head with no checks in
+ * a repository that has CI is not yet (its PR conflicts, or CI hasn't been
+ * triggered); only a repository without CI is one with nothing to gate on.
+ */
+
+import { getDefaultBranch } from "../git";
+import { git } from "../git-exec";
+import { run } from "../tasks/gh";
+import { repoSlug } from "./repo-slug";
+
+export type RepoCI = "yes" | "no" | "unknown";
+
+const YES_TTL_MS = 60 * 60 * 1000;
+const NO_TTL_MS = 10 * 60 * 1000;
+const cache = new Map<string, { at: number; ci: "yes" | "no" }>();
+
+export function clearRepoCI(): void {
+  cache.clear();
+}
+
+export interface RepoCIDeps {
+  // The files under .github/workflows on `ref`.
+  workflows: (repo: string, ref: string) => Promise<string[]>;
+  // How many checks or statuses ran on the default branch and the recent
+  // PRs; null when GitHub can't say.
+  history: (repo: string) => Promise<number | null>;
+  now: () => number;
+}
+
+const count = (out: string) => {
+  const n = Number(out.trim());
+  return out.trim() !== "" && Number.isInteger(n) && n >= 0 ? n : null;
+};
+
+export const repoCIDeps: RepoCIDeps = {
+  workflows: async (repo, ref) =>
+    (
+      await git(repo, ["ls-tree", "--name-only", ref, ".github/workflows/"], {
+        timeout: 10000,
+      })
+    )
+      .split("\n")
+      .filter((f) => /\.ya?ml$/i.test(f.trim())),
+  history: async (repo) => {
+    const slug = await repoSlug(repo);
+    if (!slug) return null;
+    const branch = await getDefaultBranch(repo);
+    const ask = (args: string[]) =>
+      run("gh", args, repo, 20000).then(count, () => null);
+    const counts = await Promise.all([
+      ask([
+        "api",
+        `repos/${slug}/commits/${branch}/check-runs?per_page=1`,
+        "--jq",
+        ".total_count",
+      ]),
+      ask([
+        "api",
+        `repos/${slug}/commits/${branch}/status`,
+        "--jq",
+        ".statuses | length",
+      ]),
+      ask([
+        "pr",
+        "list",
+        "--state",
+        "all",
+        "--limit",
+        "20",
+        "--json",
+        "statusCheckRollup",
+        "--jq",
+        "[.[] | (.statusCheckRollup // []) | length] | add // 0",
+      ]),
+    ]);
+    if (counts.some((c) => c !== null && c > 0)) return 1;
+    return counts.every((c) => c === 0) ? 0 : null;
+  },
+  now: Date.now,
+};
+
+// "unknown" when it can't be told (GitHub unreachable or backed off): the
+// ci gate waits on that, it never escalates or passes on a guess.
+export async function repoHasCI(
+  repo: string,
+  baseRef: string,
+  deps: RepoCIDeps = repoCIDeps
+): Promise<RepoCI> {
+  const hit = cache.get(repo);
+  if (hit && deps.now() - hit.at < (hit.ci === "yes" ? YES_TTL_MS : NO_TTL_MS))
+    return hit.ci;
+  const found = (ci: "yes" | "no") => {
+    cache.set(repo, { at: deps.now(), ci });
+    return ci;
+  };
+  if ((await deps.workflows(repo, baseRef).catch(() => [])).length)
+    return found("yes");
+  const seen = await deps.history(repo).catch(() => null);
+  if (seen === null) return "unknown";
+  return found(seen > 0 ? "yes" : "no");
+}

package/lib/orchestrator/signoff.ts

@@ -3,8 +3,9 @@
  * commit that was judged. With merge approvals on (merge-approvals.ts),
  * anything touching CI config, build and hook scripts, agent config, deploys
  * or secrets handling goes to Saad whatever the gates say. A repository with
- * no CI and a gate failing on two different commits go to him either way. Once a task
- * is with Saad the orchestrator doesn't merge it; he signs it off or drops it.
+ * no CI (decided from the repository, never from one head with no checks)
+ * and a gate failing on two different commits go to him either way. Once a
+ * task is with Saad the orchestrator doesn't merge it; he signs it off or drops it.
  */
 
 import { MERGED_AS, type MergeMethod } from "../tasks/merge-policy";
@@ -32,6 +33,7 @@ import { heldVerdict } from "./held";
 import { mergeApprovalsOn } from "./merge-approvals";
 import { isPaused } from "./pause";
 import { commitTime, fetchRefs, repoOf } from "./repo";
+import { repoHasCI } from "./repo-ci";
 import { DIFF_CAP, review } from "./review";
 import { workspaceStack, workspaceTask } from "./targets";
 import { ciSettleIn, waitingState } from "./task-state";
@@ -112,6 +114,8 @@ export async function judge(
         checkCount: pr.checkCount ?? 0,
         committedAt: await commitTime(repo, sha),
       }),
+      mergeable: pr.mergeable,
+      baseName: pr.base ?? task.base_branch,
       review: getCheck(task.id, sha, "review"),
       ...(await waitingState(task)),
       fromCard: !!task.lh_card_id,
@@ -203,11 +207,17 @@ export async function gateVerdict(
     }
   }
 
-  const outcomes = evaluateGates({
-    sha,
-    ruleBreaks: ruleBreaks(files, await addedLines(repo, base, sha)),
-    ...(await inputs()),
-  });
+  const ruled = ruleBreaks(files, await addedLines(repo, base, sha));
+  const live = await inputs();
+  // Asked only when it can change the answer: a head with no checks that
+  // isn't settling or conflicting.
+  const repoCI =
+    live.checks === "none" &&
+    live.settleIn === 0 &&
+    live.mergeable !== "CONFLICTING"
+      ? await repoHasCI(repo, base)
+      : undefined;
+  const outcomes = evaluateGates({ sha, ruleBreaks: ruled, ...live, repoCI });
   const head = `${work.name} (PR #${pr.number} at ${short(sha)}) can't merge:`;
   const toSaad = outcomes.find((o) => o.state === "escalate");
   if (toSaad)

package/lib/orchestrator/task-state.ts

@@ -2,6 +2,7 @@
 // live inputs to the blocked and ci gates.
 
 import type { Session } from "../db";
+import type { TaskPR } from "../tasks/state";
 import { chatStateNow } from "../chat/runner";
 import { saidSinceLastMessage } from "../chat/store";
 import { blockedReason } from "../tasks/state";
@@ -139,3 +140,33 @@ export function ciSettleIn(input: {
   const settledAt = Math.max(input.committedAt, changedAt) + SETTLE_S;
   return Math.max(0, settledAt - now);
 }
+
+// A head with no checks for this long after its PR became mergeable, in a
+// repository with CI, is news for the orchestrator (never an escalation).
+export const CHECKLESS_MS = 30 * 60 * 1000;
+
+const checkless = new Map<string, number>();
+
+// How long this head has had no checks while its PR could merge cleanly, in
+// ms, or undefined when it isn't in that state. In memory: a restart only
+// restarts the clock.
+export function checklessFor(
+  taskId: string,
+  pr: Pick<TaskPR, "state" | "checks" | "head" | "mergeable">,
+  now = Date.now()
+): number | undefined {
+  const key = `${taskId}:${pr.head ?? ""}`;
+  for (const k of checkless.keys())
+    if (k.startsWith(`${taskId}:`) && k !== key) checkless.delete(k);
+  if (
+    pr.state !== "OPEN" ||
+    pr.checks !== "none" ||
+    pr.mergeable !== "MERGEABLE"
+  ) {
+    checkless.delete(key);
+    return undefined;
+  }
+  const since = checkless.get(key) ?? now;
+  checkless.set(key, since);
+  return now - since;
+}

package/lib/orchestrator/tools.ts

@@ -75,7 +75,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   stack_status: "One stack's items, PRs and progress.",
   land: "Merge a whole stack bottom-up, each PR through the sign-off gates at its current head.",
   drop: "Reject a task: close its PR and remove its worktree. Logged with the reason.",
-  stop: "Stop a session's agent, keeping its worktree and branch.",
+  stop: "Stop a session's agent mid-turn, even while it's thinking, keeping its conversation, worktree and branch; your next message runs as its next turn.",
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
   add_project:
     "Make a git repository on this machine a project of this workspace, by its absolute path, or move the project already at that path into this workspace when it's in no workspace. Says its default branch, detected from git. Refuses a folder that isn't a git repository or that holds secrets, and a project another workspace has.",

package/lib/sessions/stop.ts

@@ -0,0 +1,28 @@
+import { endTmuxSession } from "../tmux/end";
+import { hostLink } from "../hosts/remote-api";
+import { stopChatTurn } from "../chat/stop";
+import type { Session } from "../db";
+
+// Stops a session's agent and keeps everything else, the same for every
+// caller (the orchestrator's stop tool, `aos stop`): a chat's turn ends
+// whatever it is doing, a terminal's tmux session ends. The worktree, branch
+// and conversation stay, and the next message runs as the next turn. Throws
+// when the chat can't be shown to have stopped.
+export async function stopSession(
+  s: Pick<Session, "id" | "name" | "view" | "host_id" | "tmux_name">
+): Promise<string> {
+  if (s.view === "chat") {
+    if (hostLink(s.host_id))
+      throw new Error(
+        `Couldn't stop ${s.name}: it runs on another machine; stop it there.`
+      );
+    const out = await stopChatTurn(s.id);
+    if (!out.stopped)
+      throw new Error(`Couldn't stop ${s.name}: ${out.reason}.`);
+    return out.killed
+      ? `Stopped ${s.name}: its agent didn't answer the interrupt, so it was ended. Its conversation and worktree are kept; your next message runs as its next turn.`
+      : `Stopped ${s.name}'s turn. Your next message runs as its next turn.`;
+  }
+  await endTmuxSession(s.host_id, s.tmux_name);
+  return `Stopped ${s.name}: its agent is ended, its worktree and branch are kept.`;
+}

package/lib/sidebar/shelves.ts

@@ -28,6 +28,7 @@ export interface RowStatus {
   status?: string;
   need?: SessionNeed | null;
   unread?: boolean;
+  stalled?: boolean;
   asks?: number;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
@@ -230,6 +231,7 @@ function sameStatus(a: RowStatus | undefined, b: RowStatus | undefined) {
     a.status === b.status &&
     (a.need ?? null) === (b.need ?? null) &&
     !!a.unread === !!b.unread &&
+    !!a.stalled === !!b.stalled &&
     a.asks === b.asks &&
     (a.detail ?? null) === (b.detail ?? null)
   );

package/lib/stacks/restack.ts

@@ -11,7 +11,7 @@
 import { db, stackQueries as q, type Session, type StackItemRow } from "../db";
 import { getDefaultBranch } from "../git";
 import { sendMessage } from "../bus";
-import { chatStateNow, interruptChat } from "../chat/runner";
+import { stopChatTurn } from "../chat/stop";
 import { findPRStrict, run } from "../tasks/gh";
 import type { TaskPR } from "../tasks/state";
 import { expandHome } from "../tasks/session";
@@ -64,7 +64,7 @@ export const stackNotice = (
   origin: { kind: "system", label, body } as const,
 });
 
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
 // The note on an item left alone because its agent was still working.
 export const AGENT_BUSY = "Waiting for its agent to stop";
 // How long a chat's turn may take to stop after it's interrupted.
@@ -79,17 +79,11 @@ export async function interruptAgent(
   wait = sleep
 ): Promise<boolean> {
   if (session.view === "chat") {
-    const now = () =>
-      chatStateNow(session.id).catch(() => "unreachable" as const);
-    const busy = (s: Awaited<ReturnType<typeof now>>) =>
-      s === "running" || s === "waiting" || s === "unreachable";
-    if (!busy(await now())) return true;
-    await interruptChat(session.id);
-    for (let waited = 0; waited < CHAT_STOP_WAIT_MS; waited += 500) {
-      await wait(500);
-      if (!busy(await now())) return true;
-    }
-    return false;
+    const out = await stopChatTurn(session.id, {
+      graceMs: CHAT_STOP_WAIT_MS,
+      sleep: wait,
+    });
+    return out.stopped;
   }
   const sent = await run(
     "tmux",

package/lib/status/collect.ts

@@ -21,7 +21,7 @@ import {
 } from "../providers/registry";
 import { getDb, type Session } from "../db";
 import { chatState } from "../chat/runner";
-import { chatActivityLine } from "../chat/activity";
+import { chatActivityLine, chatStall } from "../chat/activity";
 import {
   chatNeed,
   isUnread,
@@ -60,6 +60,8 @@ export interface SessionStatusResponse {
   asks?: number;
   need?: SessionNeed | null;
   unread?: boolean;
+  // A chat turn silent past the stall threshold (lib/chat/stall).
+  stalled?: boolean;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
   progress?: number | null;
@@ -464,6 +466,7 @@ async function collect(): Promise<StatusSnapshot> {
       agentType: session.agent_type,
       need: chatNeed(session, state, asks),
       unread: isUnread(session, state),
+      ...(chatStall(session.id) && { stalled: true }),
       ...(session.role === "orchestrator" && { asks }),
     };
   }

package/package.json

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