@saadnvd1/agent-os 0.3.483 → 0.3.484

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/conditions.ts

@@ -109,6 +109,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/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";
@@ -32,6 +32,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.
@@ -249,6 +251,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/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.484",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"