@saadnvd1/agent-os 0.3.482 → 0.3.484

package/README.md

@@ -323,11 +323,11 @@ The ring in the tab bar (in the composer on a phone) is how full the
 conversation's context is, measured against the room before auto-compact:
 amber past 60%, red past 85%. Tap it for the breakdown and **Compact now**.
 
-Chats and tasks compact at 150k tokens of context by default (Settings →
-Workspaces → Compact; off sets it to never), not near the model's window:
-AgentOS launches Claude Code with `CLAUDE_CODE_AUTO_COMPACT_WINDOW` set to
-that size (its floor is 100k), so the agent compacts itself mid-turn. Between
-turns AgentOS catches what it didn't: a chat over the threshold is compacted
+Two thresholds (Settings → Workspaces → Compact; 0 turns one off). Mid-turn,
+the agent compacts itself at 300k by default: AgentOS launches Claude Code
+with `CLAUDE_CODE_AUTO_COMPACT_WINDOW` set to that size (its floor is 100k),
+high enough that a long job isn't cut in half. Between
+turns AgentOS catches what it didn't: a chat over its 150k threshold is compacted
 before the next message, and so is one idle past its prompt cache (5 minutes
 or an hour, read from the agent's own usage), whose next message would
 re-read the whole conversation at the cache-write price. A chip above the
@@ -339,6 +339,13 @@ shows one quiet line with the context before and after. An orchestrator
 isn't compacted (a summary would lose the fence around what it read from
 tasks and CI): it starts a fresh conversation from its brief and the current
 state at its fresh-start threshold, or earlier once idle past its cache.
+What survives a compaction: the summary is asked to keep the task, scope
+changes, every edited file by path, what's done, in progress and next, and
+the decisions. Right after it, AgentOS hands back a note built from its own
+records (a task's brief and scope changes, the files it edited, its todos,
+the latest message and `git status`), which doesn't depend on what the
+summary kept, and tells the agent not to re-read or rewrite whole files.
+Terminal agents don't get the note yet.
 On a desktop browser the screen button attaches a screenshot of a screen or
 window you pick; on a phone, attach a screenshot as a photo.
 
@@ -349,13 +356,31 @@ turn ends. **Gate reviews** below it shows what the orchestrator's
 independent reviewer and scope check cost, by PR: they run as `claude -p`
 and leave no transcript, so each run's tokens, model and duration are read
 from its JSON result into `check_runs`, and the review's verdict says them
-too. Every compaction is kept in `chat_compactions` (who ran it, and the
-context before and after), so cost per task can be compared by date.
+too. Every compaction is kept in `chat_compactions` (who ran it, whether it
+fired `mid_turn` or `between_turns`, and the context before and after), so cost per task can be compared by date.
 
 **Esc** stops a running turn, as it does in Claude Code's terminal, unless a
 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**
@@ -845,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/fresh-start/route.ts

@@ -3,7 +3,8 @@ import { refreshSettings, setRefreshSettings } from "@/lib/chat/refresh";
 
 // When a chat's conversation starts over (lib/chat/refresh): context
 // tokens for orchestrators and for tasks, and at which chats and tasks
-// compact (lib/chat/stale); 0 for never.
+// compact: between turns (lib/chat/stale) and mid-turn, by the agent itself;
+// 0 for never.
 export async function GET() {
   return NextResponse.json(refreshSettings());
 }
@@ -16,6 +17,7 @@ export async function PUT(request: NextRequest) {
       taskTokens: body.taskTokens,
       // Its name before it also set the agents' own auto-compact.
       compactTokens: body.compactTokens ?? body.staleCompactTokens,
+      autoCompactTokens: body.autoCompactTokens,
     });
     return NextResponse.json(refreshSettings());
   } catch (error) {

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/FreshStartForm.tsx

@@ -19,7 +19,7 @@ export function FreshStartForm() {
     return <p className="text-destructive text-sm">{error.message}</p>;
   return (
     <Form
-      key={`${data.orchestratorTokens}:${data.taskTokens}:${data.compactTokens}`}
+      key={`${data.orchestratorTokens}:${data.taskTokens}:${data.compactTokens}:${data.autoCompactTokens}`}
       saved={data}
     />
   );
@@ -30,12 +30,15 @@ function Form({ saved }: { saved: RefreshSettings }) {
   const orchestrator = useThreshold(saved.orchestratorTokens, 200);
   const task = useThreshold(saved.taskTokens, 200);
   const compact = useThreshold(saved.compactTokens, 150);
-  const error = orchestrator.error ?? task.error ?? compact.error;
+  const midTurn = useThreshold(saved.autoCompactTokens, 300);
+  const error =
+    orchestrator.error ?? task.error ?? compact.error ?? midTurn.error;
   const dirty =
     !error &&
     (orchestrator.tokens !== saved.orchestratorTokens ||
       task.tokens !== saved.taskTokens ||
-      compact.tokens !== saved.compactTokens);
+      compact.tokens !== saved.compactTokens ||
+      midTurn.tokens !== saved.autoCompactTokens);
 
   return (
     <form
@@ -47,6 +50,7 @@ function Form({ saved }: { saved: RefreshSettings }) {
             orchestratorTokens: orchestrator.tokens,
             taskTokens: task.tokens,
             compactTokens: compact.tokens,
+            autoCompactTokens: midTurn.tokens,
           },
           {
             onSuccess: () => toast.success("Context settings saved"),
@@ -67,15 +71,23 @@ function Form({ saved }: { saved: RefreshSettings }) {
       <ThresholdRow label="Tasks" field={task} />
       <h3 className="pt-2 text-sm font-medium">Compact</h3>
       <p className="text-muted-foreground text-sm">
-        Chats and tasks compact when their context passes this size: Claude Code
-        does it itself, and between turns AgentOS compacts a chat over it, or
-        idle past its prompt cache, before the next message. The composer offers
-        to first. Orchestrators start fresh instead.
+        Chats and tasks compact twice over. Mid-turn, Claude Code summarizes its
+        own context when a job runs long: set this high, since it happens while
+        the agent is holding its files. Between turns, nothing is in flight, so
+        AgentOS compacts a chat over the smaller size, or idle past its prompt
+        cache, before the next message; the composer offers to first. Either way
+        AgentOS hands the agent its task, scope changes, files and todos back.
+        Orchestrators start fresh instead.
       </p>
       <ThresholdRow
-        label="Chats and tasks"
+        label="Mid-turn"
+        field={midTurn}
+        switchLabel="Let the agent compact itself mid-turn"
+      />
+      <ThresholdRow
+        label="Between turns"
         field={compact}
-        switchLabel="Compact chats and tasks at this size"
+        switchLabel="Compact chats and tasks between turns"
       />
       {error && <p className="text-destructive text-xs">{error}</p>}
       <div className="flex justify-end">

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/compact-context.ts

@@ -0,0 +1,55 @@
+/**
+ * The note an agent gets back right after a compaction, gathered from
+ * AgentOS's records (lib/chat/working-state has the rules). From the
+ * database each time rather than tracked in memory, so it is right after a
+ * deploy restarted the worker too.
+ */
+
+import os from "node:os";
+import { statusPorcelain } from "../git-exec";
+import { db, type Session } from "../db";
+import { amendmentsOf } from "../orchestrator/amendments";
+import { lastItems } from "./store";
+import { workingStateNote } from "./working-state";
+
+async function gitStatus(cwd: string): Promise<string> {
+  try {
+    const out = await statusPorcelain(cwd, {
+      timeout: 3_000,
+      maxBuffer: 64 * 1024,
+    });
+    return out.split("\n").slice(0, 40).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+// Empty when the session is gone or there is nothing to say.
+export async function compactContext(sessionId: string): Promise<string> {
+  const session = db
+    .prepare(
+      `SELECT working_directory, task_prompt, role FROM sessions WHERE id = ?`
+    )
+    .get(sessionId) as
+    | Pick<Session, "working_directory" | "task_prompt" | "role">
+    | undefined;
+  // An orchestrator starts fresh instead of compacting.
+  if (!session || session.role === "orchestrator") return "";
+  const tools = lastItems(sessionId, 400, "tool").filter(
+    (i) => i.kind === "tool"
+  );
+  const todos = lastItems(sessionId, 1, "todos").find(
+    (i) => i.kind === "todos"
+  );
+  const user = lastItems(sessionId, 1, "user").find((i) => i.kind === "user");
+  return workingStateNote({
+    taskPrompt: session.task_prompt,
+    amendments: amendmentsOf(sessionId).map((a) => a.text),
+    tools,
+    todos: todos?.todos,
+    requests: user ? [user.text] : [],
+    gitStatus: await gitStatus(
+      session.working_directory.replace(/^~/, os.homedir())
+    ),
+  });
+}

package/lib/chat/driver.ts

@@ -41,6 +41,10 @@ export interface ChatStartOptions {
   // Checked before every tool call, whatever the permissions say: why it's
   // refused, or null to let it go on to them.
   toolGuard?: ToolGuard;
+  // The note handed back to the agent right after its context is compacted
+  // (lib/chat/compact-context), empty for none. Only Claude Code has a hook
+  // for it; other drivers ignore it.
+  compactContext?: () => Promise<string>;
 }
 
 export type ToolGuard = (

package/lib/chat/drivers/claude-approvals.ts

@@ -275,3 +275,35 @@ export function preToolUseHooks(
     ...(guard ? [{ hooks: [guardHook(guard)] }] : []),
   ];
 }
+
+// After a compaction Claude Code starts the session again with source
+// "compact", and what a SessionStart hook returns as additionalContext is
+// added to the context: the one way to hand the agent something back that
+// doesn't depend on what its summary kept. A failure here never blocks it.
+export function compactedHooks(
+  context: () => Promise<string>
+): HookCallbackMatcher[] {
+  return [
+    {
+      matcher: "compact",
+      hooks: [
+        async () => {
+          try {
+            const additionalContext = await context();
+            return additionalContext
+              ? {
+                  hookSpecificOutput: {
+                    hookEventName: "SessionStart",
+                    additionalContext,
+                  },
+                }
+              : {};
+          } catch (e) {
+            console.error("building the compaction note:", e);
+            return {};
+          }
+        },
+      ],
+    },
+  ];
+}

package/lib/chat/drivers/claude.ts

@@ -10,6 +10,7 @@ import type { DriverEvent, FileSuggestion, McpServerView } from "../events";
 import { InputQueue } from "../queue";
 import {
   Approvals,
+  compactedHooks,
   isPlanFile,
   preToolUseHooks,
   sdkMode,
@@ -193,6 +194,9 @@ export const claudeDriver: ChatDriver = {
         disallowedTools: options.disallowedTools,
         hooks: {
           PreToolUse: preToolUseHooks(approvals, options.toolGuard),
+          ...(options.compactContext && {
+            SessionStart: compactedHooks(options.compactContext),
+          }),
         },
         settings: { attribution: NO_ATTRIBUTION },
         enableFileCheckpointing: true,

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 }