@saadnvd1/agent-os 0.3.482 → 0.3.484

package/lib/chat/refresh.ts

@@ -6,8 +6,9 @@
  * default: its state is in the database and its brief carries it
  * (lib/orchestrator/digest). A task keeps its progress only in its
  * conversation and its branch, so for tasks it's off unless switched on.
- * App-wide, in Settings → Workspaces, with the size at which chats and
- * tasks compact (lib/chat/stale).
+ * App-wide, in Settings → Workspaces, with the two sizes at which chats and
+ * tasks compact: mid-turn (Claude Code itself, high so a job keeps its
+ * files) and between turns (lib/chat/stale, earlier, nothing in flight).
  */
 
 import { db } from "../db";
@@ -20,16 +21,22 @@ export const TASK_KEY = "chat.task_refresh_tokens";
 export const COMPACT_KEY = "chat.stale_compact_tokens";
 export const DEFAULT_ORCHESTRATOR_TOKENS = 200_000;
 export const DEFAULT_COMPACT_TOKENS = 150_000;
+// Claude Code's own mid-turn auto-compact window: high, because a summary
+// mid-job costs the agent its files and its place.
+export const AUTO_COMPACT_KEY = "chat.auto_compact_tokens";
+export const DEFAULT_AUTO_COMPACT_TOKENS = 300_000;
 export { MIN_REFRESH_TOKENS, MAX_REFRESH_TOKENS } from "./refresh-limits";
 
 export interface RefreshSettings {
   // Context tokens at which a conversation starts over; 0 is off.
   orchestratorTokens: number;
   taskTokens: number;
-  // Context tokens at which a chat's or task's agent compacts: Claude
-  // Code's own auto-compact window, and between turns a chat over it (or
-  // idle past its cache) is compacted before the next message. 0 is off.
+  // Between turns: a chat over this size (or idle past its cache) is
+  // compacted before its next message. 0 is off.
   compactTokens: number;
+  // Mid-turn: Claude Code's own auto-compact window for a chat's or task's
+  // agent. 0 is off.
+  autoCompactTokens: number;
 }
 
 function read(key: string, fallback: number): number {
@@ -45,6 +52,7 @@ export function refreshSettings(): RefreshSettings {
     orchestratorTokens: read(ORCHESTRATOR_KEY, DEFAULT_ORCHESTRATOR_TOKENS),
     taskTokens: read(TASK_KEY, 0),
     compactTokens: read(COMPACT_KEY, DEFAULT_COMPACT_TOKENS),
+    autoCompactTokens: read(AUTO_COMPACT_KEY, DEFAULT_AUTO_COMPACT_TOKENS),
   };
 }
 
@@ -79,6 +87,11 @@ export function setRefreshSettings(input: Partial<RefreshSettings>): void {
     checked.push([TASK_KEY, checkRefreshTokens(input.taskTokens)]);
   if (input.compactTokens !== undefined)
     checked.push([COMPACT_KEY, checkRefreshTokens(input.compactTokens)]);
+  if (input.autoCompactTokens !== undefined)
+    checked.push([
+      AUTO_COMPACT_KEY,
+      checkRefreshTokens(input.autoCompactTokens),
+    ]);
   db.transaction(() => {
     for (const [key, n] of checked) put.run(key, String(n));
   })();
@@ -119,7 +132,7 @@ export function autoCompactEnv(sessionId: string): Record<string, string> {
     .get(sessionId) as
     | { role: string | null; model_provider: string | null }
     | undefined;
-  const tokens = refreshSettings().compactTokens;
+  const tokens = refreshSettings().autoCompactTokens;
   if (row?.role === "orchestrator" || tokens <= 0) return {};
   const window = compactThreshold(
     Math.max(AUTO_COMPACT_MIN, tokens),

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

@@ -1,8 +1,9 @@
 /**
- * Compacting between turns. A chat's agent compacts itself at the compact
- * threshold (Claude Code's auto-compact window, set at launch by
- * lib/agents/launch). Between turns AgentOS catches what it didn't: a chat
- * over the threshold is compacted before the next message, and so is one
+ * Compacting between turns. A chat's agent compacts itself mid-turn at its
+ * own, higher window (Claude Code's auto-compact, set at launch by
+ * lib/agents/launch). Between turns nothing is in flight, so AgentOS
+ * compacts earlier: a chat over the compact threshold is compacted before
+ * the next message, and so is one
  * whose prompt cache has expired, since that message would re-read the
  * whole history at the cache-write price (one summary turn, then a small
  * cache write instead of a huge one). The one check every send path uses:

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

@@ -41,6 +41,8 @@ import {
 } from "../../artifacts/tools";
 import type { RoleExtras } from "./extras";
 import { compactThreshold, refreshSettings, refreshedNote } from "../refresh";
+import { compactContext } from "../compact-context";
+import { COMPACT_BRIEF, COMPACT_INSTRUCTIONS } from "../working-state";
 import { compactionDue, staleLabel, type Staleness } from "../stale";
 import type { WorkerCommand, WorkerEvent } from "./protocol";
 
@@ -48,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.
@@ -102,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.
@@ -164,6 +171,7 @@ export class ChatHost {
     this.atRest = driver.atRest !== false;
     const cwd = session.working_directory.replace(/^~/, os.homedir());
     const env = { ...agentEnv(session.id), ...extras.env };
+    const orchestrator = session.role === "orchestrator";
     // Every chat can show visuals, asked for like any tool under its access
     // setting (they read files and reach the web). Not an orchestrator: it
     // reads other sessions' text, and a browser would be a way out for it.
@@ -196,6 +204,7 @@ export class ChatHost {
         sessionRunningBrief(session.id),
         BUS_BRIEF,
         visuals && VISUALS_BRIEF,
+        !orchestrator && COMPACT_BRIEF,
       ]
         .filter(Boolean)
         .join("\n\n"),
@@ -211,6 +220,10 @@ export class ChatHost {
       disallowedTools: extras.disallowedTools,
       permissionMode: extras.permissionMode,
       toolGuard: extras.toolGuard,
+      // Not an orchestrator: it starts a fresh conversation instead.
+      compactContext: orchestrator
+        ? undefined
+        : () => compactContext(session.id),
     });
     this.suggestion = session.chat_suggestion ?? null;
     try {
@@ -319,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--;
@@ -429,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;
@@ -554,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
         ) {
@@ -616,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.
@@ -655,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
@@ -725,7 +751,7 @@ export class ChatHost {
     };
     this.currentTurn = null;
     this.stopping = null;
-    this.conversation.send("/compact");
+    this.conversation.send(`/compact ${COMPACT_INSTRUCTIONS}`);
     this.setState("running");
     console.error(
       `${new Date().toISOString()} compacting ${this.session.id} before a message: ${stale.stale ? `idle ${Math.round(stale.idleMs / 60_000)}m, ` : ""}${stale.tokens} tokens`

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/chat/working-state.ts

@@ -0,0 +1,111 @@
+/**
+ * What an agent needs to keep its place across a compaction. Claude Code's
+ * summary decides for itself what mattered, and a long job's task, its scope
+ * changes and the files it was editing are exactly what it dropped: the
+ * agent re-read them and then rewrote whole files to be sure. So the summary
+ * is told what to keep (COMPACT_INSTRUCTIONS), and right after it AgentOS
+ * hands back a note built from its own records (workingStateNote), which
+ * doesn't depend on what the summary kept.
+ *
+ * Pure, so the rules are tested without a database (lib/chat/compact-context
+ * gathers the inputs).
+ */
+
+import type { ChatItem } from "./events";
+
+export const COMPACT_INSTRUCTIONS = [
+  "Keep, verbatim where short: the task or request you are working on and any changes to its scope.",
+  "List every file you created or edited, by absolute path, and what you changed in each.",
+  "State what is done, what is in progress, and the exact next step.",
+  "Keep the decisions made and why, and any commands or checks still to run.",
+  "After the summary, do not re-read whole files you were editing: search for the spot and edit it in place, and never rewrite a whole large file to change a part of it.",
+].join(" ");
+
+// In the system prompt, which the summary request reuses and a summary
+// can't drop.
+export const COMPACT_BRIEF = `If your context is compacted, the summary must: ${COMPACT_INSTRUCTIONS}`;
+
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+const MAX_FILES = 20;
+const MAX_PROMPT = 8_000;
+const MAX_REQUEST = 1_500;
+const MAX_NOTE = 12_000;
+
+type Todo = Extract<ChatItem, { kind: "todos" }>["todos"][number];
+
+export interface WorkingState {
+  // The task's own prompt, when it is one, and its scope changes (oldest
+  // first).
+  taskPrompt?: string | null;
+  amendments?: string[];
+  // Tool calls and the latest todos and user messages, oldest first.
+  tools?: Extract<ChatItem, { kind: "tool" }>[];
+  todos?: Todo[];
+  requests?: string[];
+  // `git status --short`, when the directory is a repository.
+  gitStatus?: string;
+}
+
+const cut = (text: string, max: number) =>
+  text.length > max ? `${text.slice(0, max)}\n… (cut)` : text;
+
+// The path a file-changing tool call is about, newest first, each once.
+export function editedFiles(
+  tools: Extract<ChatItem, { kind: "tool" }>[]
+): string[] {
+  const seen = new Set<string>();
+  for (const t of [...tools].reverse()) {
+    if (!EDIT_TOOLS.has(t.name) || t.status === "error") continue;
+    const input = (t.input ?? {}) as Record<string, unknown>;
+    const path = input.file_path ?? input.notebook_path ?? t.diff?.path;
+    if (typeof path === "string" && path) seen.add(path);
+    if (seen.size >= MAX_FILES) break;
+  }
+  return [...seen];
+}
+
+const MARK: Record<Todo["status"], string> = {
+  completed: "done",
+  in_progress: "in progress",
+  pending: "next",
+};
+
+export function workingStateNote(s: WorkingState): string {
+  const parts: string[] = [];
+  const prompt = s.taskPrompt?.trim();
+  if (prompt) parts.push(`## Your task\n${cut(prompt, MAX_PROMPT)}`);
+  const amendments = (s.amendments ?? []).filter((a) => a.trim());
+  if (amendments.length)
+    parts.push(
+      `## Scope changes since it started (oldest first; they change the task above)\n${amendments
+        .map((a, i) => `${i + 1}. ${cut(a.trim(), MAX_REQUEST)}`)
+        .join("\n")}`
+    );
+  const files = editedFiles(s.tools ?? []);
+  if (files.length)
+    parts.push(
+      `## Files you were editing (newest first)\n${files.map((f) => `- ${f}`).join("\n")}`
+    );
+  if (s.todos?.length)
+    parts.push(
+      `## Your todo list\n${s.todos.map((t) => `- [${MARK[t.status]}] ${t.text}`).join("\n")}`
+    );
+  const requests = (s.requests ?? [])
+    .map((r) => r.trim())
+    // The task's own prompt is already above.
+    .filter((r) => r && !(prompt && r.startsWith(prompt.slice(0, 200))));
+  if (requests.length)
+    parts.push(
+      `## Latest from the reader\n${requests.map((r) => cut(r, MAX_REQUEST)).join("\n\n")}`
+    );
+  if (s.gitStatus?.trim())
+    parts.push(`## git status\n${cut(s.gitStatus.trim(), 1_500)}`);
+  if (!parts.length) return "";
+  parts.push(
+    "This note is from AgentOS, rebuilt from its own records after the context was compacted; the summary has the rest. Carry on from the next step. Don't re-read whole files you were editing (search for the spot), and edit in place rather than rewriting a whole file."
+  );
+  return cut(
+    `(Your context was just compacted. Where you were:)\n\n${parts.join("\n\n")}`,
+    MAX_NOTE
+  );
+}

package/lib/db/migrations.ts

@@ -1459,6 +1459,19 @@ const migrations: Migration[] = [
         );
       })(),
   },
+  {
+    id: 64,
+    name: "chat_compactions_phase",
+    up: (db) => {
+      // Whether the agent compacted itself mid-turn or AgentOS (or a typed
+      // /compact) did between turns; null on rows from before.
+      const columns = db
+        .prepare(`PRAGMA table_info(chat_compactions)`)
+        .all() as { name: string }[];
+      if (!columns.some((c) => c.name === "phase"))
+        db.exec(`ALTER TABLE chat_compactions ADD COLUMN phase TEXT`);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

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)
   );