@saadnvd1/agent-os 0.3.481 → 0.3.483

package/components/Chat/timeline-selection.test.ts

@@ -0,0 +1,146 @@
+import "./composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ChatItem } from "@/lib/chat/events";
+import { groupTimeline } from "@/lib/chat/group";
+import { copySelection } from "./copy-selection";
+import { TimelineRows } from "./ChatPanel";
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+const user = (id: string, text: string): ChatItem => ({
+  id,
+  kind: "user",
+  createdAt: 1,
+  text,
+  tagged: true,
+});
+const reply = (id: string, text: string, streaming = false): ChatItem => ({
+  id,
+  kind: "assistant",
+  createdAt: 2,
+  text,
+  streaming,
+});
+
+describe("the conversation's rows", () => {
+  let host: HTMLElement;
+  let root: Root;
+  const actions = () => ({ respond: vi.fn() }) as never;
+  const show = (items: ChatItem[], a = actions()) =>
+    act(() =>
+      root.render(
+        createElement(TimelineRows, {
+          blocks: groupTimeline(items),
+          actions: a,
+        })
+      )
+    );
+  const rows = () => [...host.querySelectorAll("[data-block]")];
+
+  beforeEach(() => {
+    host = document.createElement("div");
+    document.body.append(host);
+    root = createRoot(host);
+  });
+  afterEach(() => {
+    act(() => root.unmount());
+    host.remove();
+    document.getSelection()?.removeAllRanges();
+  });
+
+  it("keeps a selection across messages through streaming updates", async () => {
+    const items = [
+      user("u1", "first"),
+      reply("a1", "second", true),
+      user("u2", "third"),
+    ];
+    await show(items);
+    const [r1, , r3] = rows();
+    const range = document.createRange();
+    range.setStart(r1, 0);
+    range.setEnd(r3, r3.childNodes.length);
+    document.getSelection()!.removeAllRanges();
+    document.getSelection()!.addRange(range);
+
+    await show([
+      items[0],
+      reply("a1", "second, and more words streamed in", true),
+      items[2],
+      reply("a2", "a new reply at the end", true),
+    ]);
+    await show(
+      [
+        items[0],
+        reply("a1", "second, and more words streamed in", false),
+        items[2],
+        reply("a2", "a new reply at the end, done", false),
+      ],
+      actions()
+    );
+
+    const after = rows();
+    expect(after).toHaveLength(4);
+    expect(after[0]).toBe(r1);
+    expect(after[2]).toBe(r3);
+    expect(r1.isConnected && r3.isConnected).toBe(true);
+    expect(after.map((r) => r.getAttribute("data-block"))).toEqual([
+      "u1",
+      "a1",
+      "u2",
+      "a2",
+    ]);
+    const sel = document.getSelection()!;
+    expect(sel.rangeCount).toBe(1);
+    expect(sel.isCollapsed).toBe(false);
+    expect(sel.getRangeAt(0).startContainer).toBe(r1);
+    expect(sel.getRangeAt(0).endContainer).toBe(r3);
+  });
+
+  describe("copying", () => {
+    const copy = (items: ChatItem[]) => {
+      const data: Record<string, string> = {};
+      const e = {
+        currentTarget: host,
+        clipboardData: { setData: (t: string, v: string) => (data[t] = v) },
+        preventDefault: vi.fn(),
+      };
+      copySelection(e as never, new Map(items.map((i) => [i.id, i])));
+      return { data, prevented: e.preventDefault.mock.calls.length > 0 };
+    };
+
+    it("gives speakers and blank lines across messages, from their source", async () => {
+      const items = [
+        user("u1", "fix `the` bug"),
+        reply("a1", "Done.\n\n- one\n- two"),
+        user("u2", "thanks"),
+      ];
+      await show(items);
+      const [r1, , r3] = rows();
+      const range = document.createRange();
+      range.selectNodeContents(host);
+      range.setStart(r1, 0);
+      range.setEnd(r3, r3.childNodes.length);
+      document.getSelection()!.addRange(range);
+      const { data, prevented } = copy(items);
+      expect(prevented).toBe(true);
+      expect(data["text/plain"]).toBe(
+        "User:\nfix `the` bug\n\nAssistant:\nDone.\n\n- one\n- two\n\nUser:\nthanks"
+      );
+    });
+
+    it("leaves a selection inside one message to the browser", async () => {
+      const items = [user("u1", "first"), reply("a1", "second words")];
+      await show(items);
+      const text = rows()[1].querySelector("p")!.firstChild!;
+      const range = document.createRange();
+      range.setStart(text, 1);
+      range.setEnd(text, 4);
+      document.getSelection()!.addRange(range);
+      expect(copy(items)).toEqual({ data: {}, prevented: false });
+    });
+  });
+});

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/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/copy-selection.ts

@@ -0,0 +1,58 @@
+import type { ChatItem } from "./events";
+import { eventParts, originOf } from "./origin";
+
+export interface TranscriptPart {
+  speaker: string;
+  text: string;
+}
+
+// Who a message is from when copied, or null for rows that aren't part of the
+// conversation itself (tools, turn markers, plans, approvals...).
+export function speakerOf(item: ChatItem): string | null {
+  switch (item.kind) {
+    case "user": {
+      const origin = originOf(item);
+      if (!origin) return "User";
+      return origin.kind === "decision" ? "Decision" : origin.label;
+    }
+    case "assistant":
+      return "Assistant";
+    case "error":
+      return "Error";
+    default:
+      return null;
+  }
+}
+
+// The whole message as written, for one a selection covers entirely.
+export function sourceText(item: ChatItem): string {
+  switch (item.kind) {
+    case "user": {
+      const origin = originOf(item);
+      if (!origin) return item.text;
+      const { body, decided } = eventParts(item, origin);
+      return [...decided, body].join("\n\n");
+    }
+    case "assistant":
+      return item.text;
+    case "error":
+      return item.message;
+    default:
+      return "";
+  }
+}
+
+// `Speaker:` then the text, a blank line between messages. Neighbours from
+// the same speaker (a reply split around its tools) read as one message.
+export function formatTranscript(parts: TranscriptPart[]): string {
+  const merged: TranscriptPart[] = [];
+  for (const p of parts) {
+    const text = p.text.trim();
+    if (!text) continue;
+    const last = merged.at(-1);
+    if (last && last.speaker === p.speaker)
+      last.text = `${last.text}\n\n${text}`;
+    else merged.push({ speaker: p.speaker, text });
+  }
+  return merged.map((p) => `${p.speaker}:\n${p.text}`).join("\n\n");
+}

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/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/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/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";
 
@@ -164,6 +166,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 +199,7 @@ export class ChatHost {
         sessionRunningBrief(session.id),
         BUS_BRIEF,
         visuals && VISUALS_BRIEF,
+        !orchestrator && COMPACT_BRIEF,
       ]
         .filter(Boolean)
         .join("\n\n"),
@@ -211,6 +215,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 {
@@ -725,7 +733,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/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).