@saadnvd1/agent-os 0.3.464 → 0.3.466

package/lib/chat/files.ts

@@ -1,5 +1,6 @@
 import { execFile } from "child_process";
 import { promisify } from "util";
+import { git } from "../git-exec";
 import type { FileSuggestion } from "./events";
 import {
   indexPaths,
@@ -33,11 +34,36 @@ export function sweepFileIndexes(now = Date.now()): void {
 
 export const fileIndexCount = () => cache.size;
 
+const LIST_TIMEOUT_MS = 5000;
+
+export interface Lister {
+  // The program it needs.
+  cmd: string;
+  list: (cwd: string) => Promise<string>;
+}
+
 // Ways to list a folder's files with ignored ones left out: ripgrep, or
 // git where ripgrep isn't installed.
-export const LISTERS: [string, string[]][] = [
-  ["rg", ["--files", "--hidden", "-g", "!.git"]],
-  ["git", ["ls-files", "--cached", "--others", "--exclude-standard"]],
+export const LISTERS: Lister[] = [
+  {
+    cmd: "rg",
+    list: async (cwd) =>
+      (
+        await execFileAsync("rg", ["--files", "--hidden", "-g", "!.git"], {
+          cwd,
+          maxBuffer: 64 * 1024 * 1024,
+          timeout: LIST_TIMEOUT_MS,
+        })
+      ).stdout,
+  },
+  {
+    cmd: "git",
+    list: (cwd) =>
+      git(cwd, ["ls-files", "--cached", "--others", "--exclude-standard"], {
+        timeout: LIST_TIMEOUT_MS,
+        maxBuffer: 64 * 1024 * 1024,
+      }),
+  },
 ];
 
 // The folder's files, for @mentions when no agent is running to match them
@@ -46,13 +72,9 @@ export async function listFiles(
   cwd: string,
   listers = LISTERS
 ): Promise<IndexedPath[]> {
-  for (const [cmd, args] of listers) {
+  for (const { list } of listers) {
     try {
-      const { stdout } = await execFileAsync(cmd, args, {
-        cwd,
-        maxBuffer: 64 * 1024 * 1024,
-        timeout: 5000,
-      });
+      const stdout = await list(cwd);
       return indexPaths(
         withFolders(stdout.split("\n").filter(Boolean).slice(0, MAX_FILES))
       );

package/lib/chat/refresh.ts

@@ -6,7 +6,8 @@
  * 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.
+ * App-wide, in Settings → Workspaces, with the size past which an idle
+ * chat is compacted before a message goes in (lib/chat/stale).
  */
 
 import { db } from "../db";
@@ -14,13 +15,18 @@ import { MAX_REFRESH_TOKENS, MIN_REFRESH_TOKENS } from "./refresh-limits";
 
 export const ORCHESTRATOR_KEY = "orchestrator.refresh_tokens";
 export const TASK_KEY = "chat.task_refresh_tokens";
+export const STALE_COMPACT_KEY = "chat.stale_compact_tokens";
 export const DEFAULT_ORCHESTRATOR_TOKENS = 200_000;
+export const DEFAULT_STALE_COMPACT_TOKENS = 150_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 above which a chat whose prompt cache has expired is
+  // compacted before the next message; 0 is off.
+  staleCompactTokens: number;
 }
 
 function read(key: string, fallback: number): number {
@@ -35,6 +41,7 @@ export function refreshSettings(): RefreshSettings {
   return {
     orchestratorTokens: read(ORCHESTRATOR_KEY, DEFAULT_ORCHESTRATOR_TOKENS),
     taskTokens: read(TASK_KEY, 0),
+    staleCompactTokens: read(STALE_COMPACT_KEY, DEFAULT_STALE_COMPACT_TOKENS),
   };
 }
 
@@ -49,7 +56,7 @@ export function checkRefreshTokens(value: unknown): number {
     value > MAX_REFRESH_TOKENS
   )
     throw new Error(
-      `A fresh-start threshold is off or between ${MIN_REFRESH_TOKENS / 1000}k and ${MAX_REFRESH_TOKENS / 1000}k tokens`
+      `A context threshold is off or between ${MIN_REFRESH_TOKENS / 1000}k and ${MAX_REFRESH_TOKENS / 1000}k tokens`
     );
   return value;
 }
@@ -67,6 +74,11 @@ export function setRefreshSettings(input: Partial<RefreshSettings>): void {
     ]);
   if (input.taskTokens !== undefined)
     checked.push([TASK_KEY, checkRefreshTokens(input.taskTokens)]);
+  if (input.staleCompactTokens !== undefined)
+    checked.push([
+      STALE_COMPACT_KEY,
+      checkRefreshTokens(input.staleCompactTokens),
+    ]);
   db.transaction(() => {
     for (const [key, n] of checked) put.run(key, String(n));
   })();

package/lib/chat/runner.ts

@@ -8,6 +8,7 @@
 import { randomUUID } from "crypto";
 import os from "os";
 import { db, type Session } from "../db";
+import type { CompactFirst } from "./stale";
 import type {
   ApprovalDecision,
   ChatContext,
@@ -329,6 +330,8 @@ export async function sendChat(
     images?: ChatImage[];
     // Typed in the composer: waits in the queue while a turn runs.
     queue?: boolean;
+    // Compact a stale chat first (lib/chat/stale).
+    compact?: CompactFirst;
   } & SentBy
 ): Promise<void> {
   const text = input.text.trim();
@@ -356,6 +359,7 @@ export async function sendChat(
     images: input.images,
     ...sentBy(input),
     queue: input.queue,
+    compact: input.compact,
   });
 }
 
@@ -486,6 +490,8 @@ async function resumeCutOff(sessionId: string): Promise<void> {
       text: RESUME_NOTE,
       from: "agentos",
       origin: { kind: "event", label: "AgentOS" },
+      // Down past its cache, a long chat is compacted before it carries on.
+      compact: "auto",
     });
     if (task)
       queueEvent(
@@ -552,7 +558,7 @@ export async function chatFileSuggestions(
 // only then has it accepted it. "queued" when a turn was already running.
 export async function sendChatConfirmed(
   sessionId: string,
-  input: { text: string; id?: string } & SentBy,
+  input: { text: string; id?: string; compact?: CompactFirst } & SentBy,
   timeoutMs = 10_000
 ): Promise<"delivered" | "queued"> {
   const text = input.text.trim();
@@ -607,6 +613,7 @@ export async function sendChatConfirmed(
       id,
       text,
       ...sentBy(input),
+      compact: input.compact,
     });
     await accepted;
   } finally {

package/lib/chat/stale.ts

@@ -0,0 +1,95 @@
+/**
+ * Stale chats: a message sent to a conversation whose prompt cache has
+ * expired re-reads the whole history at the cache-write price. When it is
+ * also long, compacting first is far cheaper than carrying it (one summary
+ * turn, then a small cache write instead of a huge one). The one check every
+ * send path uses: the composer to offer it (components/Chat/StaleChip), the
+ * chat worker to do it for automated sends (lib/chat/worker/host).
+ *
+ * Pure, so the browser and the worker read the same rule.
+ */
+
+import type { ChatContext, ChatItem, ChatState } from "./events";
+import { formatTokens } from "./context";
+
+// How a send treats a stale chat: "auto" compacts first only when it is
+// stale (automated sends); "yes" compacts first because the reader chose
+// to (the composer's chip). Absent, it never does.
+export type CompactFirst = "auto" | "yes";
+
+// The prompt-cache lifetime a turn wrote with, read from its usage: the
+// session runs with one or the other, and only a write says which. A turn
+// that only read the cache says nothing.
+export function cacheTtlMs(
+  cacheCreation:
+    | {
+        ephemeral_5m_input_tokens?: number;
+        ephemeral_1h_input_tokens?: number;
+      }
+    | null
+    | undefined
+): number | undefined {
+  if (!cacheCreation) return undefined;
+  if ((cacheCreation.ephemeral_1h_input_tokens ?? 0) > 0) return 60 * 60_000;
+  if ((cacheCreation.ephemeral_5m_input_tokens ?? 0) > 0) return 5 * 60_000;
+  return undefined;
+}
+
+export interface Staleness {
+  idleMs: number;
+  tokens: number;
+}
+
+// Stale: no turn running, the last one ended longer ago than the cache it
+// wrote lives, and the context is above the threshold (0 is off). Null when
+// it isn't, or when the chat never said which cache it uses.
+export function staleness(
+  context: ChatContext | null | undefined,
+  opts: { state: ChatState; thresholdTokens: number; now?: number }
+): Staleness | null {
+  if (opts.state === "running" || opts.state === "waiting") return null;
+  if (!context?.cacheTtlMs || opts.thresholdTokens <= 0) return null;
+  const idleMs = (opts.now ?? Date.now()) - context.at;
+  if (idleMs <= context.cacheTtlMs) return null;
+  if (context.usedTokens <= opts.thresholdTokens) return null;
+  return { idleMs, tokens: context.usedTokens };
+}
+
+export function formatIdle(ms: number): string {
+  const m = Math.floor(ms / 60_000);
+  if (m < 120) return `${m}m`;
+  const h = Math.floor(m / 60);
+  return h < 48 ? `${h}h` : `${Math.floor(h / 24)}d`;
+}
+
+// "Idle 47m · 412k context"
+export function staleLabel(s: Staleness): string {
+  return `Idle ${formatIdle(s.idleMs)} · ${formatTokens(s.tokens)} context`;
+}
+
+// Whether the composer's send compacts first: the chip was showing and the
+// reader didn't pick "Send as-is". A slash command goes as typed.
+export function composerCompacts(
+  text: string,
+  context: ChatContext | null | undefined,
+  opts: { state: ChatState; thresholdTokens: number; asIs: boolean }
+): boolean {
+  if (opts.asIs || text.trimStart().startsWith("/")) return false;
+  return !!staleness(context, opts);
+}
+
+// The chat's line for a compaction: "Compacted before sending · idle 47m ·
+// 412k → 38k tokens" when it ran ahead of a message to a stale chat.
+export function compactedLine(
+  item: Extract<ChatItem, { kind: "compacted" }>
+): string {
+  const head =
+    item.idleMs !== undefined
+      ? `Compacted before sending · idle ${formatIdle(item.idleMs)}`
+      : item.trigger === "auto"
+        ? "Context compacted automatically"
+        : "Context compacted";
+  if (item.before === undefined) return head;
+  const after = item.after === undefined ? "…" : formatTokens(item.after);
+  return `${head} · ${formatTokens(item.before)} → ${after} tokens`;
+}

package/lib/chat/worker/host.ts

@@ -13,6 +13,7 @@ import { resolveModelForAgent } from "../../model-catalog";
 import { chatDriverFor } from "../drivers";
 import type { ChatConversation } from "../driver";
 import type {
+  ChatContext,
   ChatImage,
   ChatItem,
   ChatState,
@@ -35,7 +36,8 @@ import {
   visualsTools,
 } from "../../artifacts/tools";
 import type { RoleExtras } from "./extras";
-import { refreshedNote } from "../refresh";
+import { refreshSettings, refreshedNote } from "../refresh";
+import { staleLabel, staleness, type Staleness } from "../stale";
 import type { WorkerCommand, WorkerEvent } from "./protocol";
 
 // How soon after a stopped turn ends a turn the agent starts on its own
@@ -123,6 +125,19 @@ export class ChatHost {
   // size can't end every conversation after one turn.
   private freshConversation: boolean;
   private contextBase: number | null = null;
+  // How full the conversation was at its last turn's end (lib/chat/stale).
+  private context: ChatContext | null = null;
+  // A compaction run ahead of a message to a stale chat: the message waits
+  // at the front of the queue until it ends (compactFirst).
+  private compacting: {
+    idleMs: number;
+    before: number;
+    done?: boolean;
+  } | null = null;
+  // Its line, until the agent's next measure gives the size after.
+  private compactedLine: Extract<ChatItem, { kind: "compacted" }> | null = null;
+  // An orchestrator gone stale starts over rather than compacting.
+  private staleRefresh: Staleness | null = null;
   readonly done: Promise<void>;
 
   constructor(
@@ -182,11 +197,19 @@ export class ChatHost {
       permissionMode: extras.permissionMode,
     });
     this.suggestion = session.chat_suggestion ?? null;
+    try {
+      this.context = session.chat_context
+        ? (JSON.parse(session.chat_context) as ChatContext)
+        : null;
+    } catch {
+      this.context = null;
+    }
     this.refresh = extras.refresh;
     this.freshConversation = !session.claude_session_id;
     if (session.chat_refreshed)
       this.refreshedNote = refreshedNote(
-        extras.refresh?.role ?? "task",
+        extras.refresh?.role ??
+          (session.role === "orchestrator" ? "orchestrator" : "task"),
         session.chat_refreshed
       );
     // Told only an orchestrator whose tools changed since its last worker:
@@ -222,6 +245,12 @@ export class ChatHost {
     try {
       for await (const e of this.conversation.events) {
         if (e.type === "item") {
+          // A compaction run for a stale chat shows as its one line; what
+          // a failed one printed still shows.
+          if (this.compacting?.done && e.item.kind === "command_output")
+            continue;
+          if (this.compacting && e.item.kind === "compacted")
+            e.item = this.compactedItem(e.item);
           if ("streaming" in e.item && e.item.streaming)
             this.streaming.set(e.item.id, e.item);
           else this.streaming.delete(e.item.id);
@@ -259,7 +288,9 @@ export class ChatHost {
             JSON.stringify(e.context),
             this.session.id
           );
+          this.context = e.context;
           this.emit(e);
+          this.settleCompactedLine(e.context.usedTokens);
           this.refreshIfFull(e.context.usedTokens);
         } else if (e.type === "turn_start") {
           this.turnsStarted++;
@@ -303,6 +334,8 @@ export class ChatHost {
             // A send waiting on the same change may have started a turn
             // meanwhile: that turn is running, not idle.
             if (this.busy()) continue;
+            // The compaction ran (or failed): its message is first in line.
+            this.compacting = null;
             if (this.sendQueued()) continue;
           }
           // A stopped turn can still settle an approval after it ended.
@@ -503,7 +536,13 @@ export class ChatHost {
           this.sendUser(cmd, true);
           return;
         }
-        if (cmd.queue && (this.busy() || listQueue(this.session.id).length)) {
+        if (this.compactFirst(cmd)) return;
+        // A compaction run for an earlier message takes nothing in: what's
+        // sent meanwhile goes behind that message.
+        if (
+          (cmd.queue || this.compacting) &&
+          (this.busy() || listQueue(this.session.id).length)
+        ) {
           // Behind the running turn, and behind anything queued before it.
           enqueue(this.session.id, cmd);
           this.emit({ type: "queue" });
@@ -620,6 +659,88 @@ export class ChatHost {
     this.close();
   }
 
+  // A stale chat (lib/chat/stale) is compacted before the message goes in,
+  // only between turns: the message waits at the front of the queue, and
+  // the compaction's end sends it. "yes" is the reader's choice, made on
+  // what the composer showed; "auto" checks for itself.
+  private compactFirst(cmd: Extract<WorkerCommand, { type: "send" }>): boolean {
+    if (!cmd.compact || this.busy() || this.closed || this.handingOver())
+      return false;
+    const stale = this.staleNow(cmd.compact);
+    if (!stale) return false;
+    try {
+      enqueue(this.session.id, cmd);
+    } catch {
+      // A full queue: it goes in as it is.
+      return false;
+    }
+    moveToFront(this.session.id, cmd.id);
+    this.emit({ type: "queue" });
+    // An orchestrator isn't compacted: a summary would carry what it read
+    // from tasks and CI without its untrusted fence. It starts a fresh
+    // conversation from its brief and the database instead, as at its
+    // threshold, and the next worker sends the message.
+    if (this.session.role === "orchestrator") {
+      this.staleRefresh = stale;
+      this.refreshAt = stale.tokens;
+      this.retiring = true;
+      this.retireWaited = true;
+      this.retireIfDone();
+      return true;
+    }
+    this.compacting = { idleMs: stale.idleMs, before: stale.tokens };
+    this.currentTurn = null;
+    this.stopping = null;
+    this.conversation.send("/compact");
+    this.setState("running");
+    console.error(
+      `${new Date().toISOString()} compacting ${this.session.id} before a message: idle ${Math.round(stale.idleMs / 60_000)}m, ${stale.tokens} tokens`
+    );
+    return true;
+  }
+
+  private staleNow(compact: "auto" | "yes"): Staleness | null {
+    const context = this.context;
+    // Only an agent that says which cache it uses has one to lose.
+    if (!context?.cacheTtlMs) return null;
+    if (compact === "yes")
+      return { idleMs: Date.now() - context.at, tokens: context.usedTokens };
+    return staleness(context, {
+      state: this.state,
+      thresholdTokens: refreshSettings().staleCompactTokens,
+    });
+  }
+
+  private compactedItem(
+    item: Extract<ChatItem, { kind: "compacted" }>
+  ): ChatItem {
+    if (this.compacting) this.compacting.done = true;
+    const line = {
+      ...item,
+      idleMs: this.compacting?.idleMs,
+      before: item.before ?? this.compacting?.before,
+    };
+    this.compactedLine = line.after === undefined ? line : null;
+    if (line.after !== undefined) this.logCompacted(line);
+    return line;
+  }
+
+  // The size after, from the measure that follows the compaction's result.
+  private settleCompactedLine(usedTokens: number): void {
+    const line = this.compactedLine;
+    if (!line) return;
+    this.compactedLine = null;
+    const settled = { ...line, after: usedTokens };
+    this.record(settled);
+    this.logCompacted(settled);
+  }
+
+  private logCompacted(line: { before?: number; after?: number }): void {
+    console.error(
+      `${new Date().toISOString()} compacted ${this.session.id}: ${line.before ?? "?"} -> ${line.after ?? "?"} tokens`
+    );
+  }
+
   // Past its threshold, once: it retires at the next turn boundary, as for
   // a deploy, without waiting for the agent's guess at the next message
   // (the new conversation never saw what it guessed from).
@@ -643,13 +764,21 @@ export class ChatHost {
          chat_suggestion = NULL, chat_context = NULL, chat_restarted = 0,
          chat_refreshed = ? WHERE id = ?`
     ).run(this.refreshAt, this.session.id);
+    const brief = `its brief${this.session.role === "orchestrator" ? " and the current state from AgentOS" : ""}`;
+    const stale = this.staleRefresh;
     this.record({
       id: `note-refresh-${Date.now()}`,
       kind: "note",
       tone: "note",
-      text: `Context reached ${Math.round(this.refreshAt / 1000)}k tokens: the agent starts a fresh conversation with its brief${this.refresh?.role === "orchestrator" ? " and the current state from AgentOS" : ""} at its next message.`,
+      text: stale
+        ? `${staleLabel(stale)}, past its prompt cache: the agent starts a fresh conversation with ${brief} before the next message.`
+        : `Context reached ${Math.round(this.refreshAt / 1000)}k tokens: the agent starts a fresh conversation with ${brief} at its next message.`,
       createdAt: Date.now(),
     });
+    if (stale)
+      console.error(
+        `${new Date().toISOString()} fresh start for stale ${this.session.id}: ${stale.tokens} tokens, idle ${Math.round(stale.idleMs / 60_000)}m`
+      );
   }
 
   // Retiring, and nothing in the background keeps it: messages wait in the

package/lib/chat/worker/protocol.ts

@@ -18,6 +18,7 @@ import type {
   PeerMessage,
 } from "../events";
 import type { UndoResult } from "../driver";
+import type { CompactFirst } from "../stale";
 
 export const PROTOCOL_VERSION = 1;
 
@@ -35,6 +36,8 @@ export type WorkerCommand =
       // From the composer: waits its turn behind a running one, in the
       // queue, rather than joining it.
       queue?: boolean;
+      // Compact a stale conversation before this goes in (lib/chat/stale).
+      compact?: CompactFirst;
     }
   // A queued message goes next: the running turn stops for it.
   // `during`: the user message whose turn the reader saw running; only that

package/lib/done/remote.ts

@@ -4,7 +4,7 @@
 
 import type { Session } from "../db";
 import type { TaskPR } from "../tasks";
-import { run } from "../tasks/gh";
+import { git, gitPush } from "../git-exec";
 import { projectPathFor } from "../tasks/session";
 import { PROTECTED_BRANCHES } from "../tasks/finish";
 import { liveChildren } from "../stacks/guard";
@@ -23,15 +23,14 @@ export async function deleteMergedRemote(
     liveChildren(s.id).length
   )
     return false;
-  const line = await run(
-    "git",
-    ["ls-remote", "--heads", "origin", `refs/heads/${branch}`],
+  const line = await git(
     repo,
-    30000
+    ["ls-remote", "--heads", "origin", `refs/heads/${branch}`],
+    { timeout: 30000 }
   ).catch(() => "");
   const tip = line.trim().split(/\s+/)[0];
   if (!tip || tip !== pr.head) return false;
-  return run("git", ["push", "origin", "--delete", branch], repo, 60000)
+  return gitPush(repo, ["origin", "--delete", branch], { timeout: 60000 })
     .then(() => true)
     .catch(() => false);
 }

package/lib/done/testing.ts

@@ -4,18 +4,13 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { execFileSync } from "child_process";
+import { gitSync } from "../git-exec";
 
 // Old enough that CI counts as settled on every commit.
 const env = { ...process.env, GIT_COMMITTER_DATE: "2026-01-01T00:00:00Z" };
 
 export const git = (cwd: string, ...args: string[]) =>
-  execFileSync("git", args, {
-    cwd,
-    encoding: "utf8",
-    stdio: "pipe",
-    env,
-  }).trim();
+  gitSync(cwd, args, { env }).trim();
 
 export function commitFile(cwd: string, file: string, text: string): string {
   fs.mkdirSync(path.dirname(path.join(cwd, file)), { recursive: true });

package/lib/done/worktree.ts

@@ -7,7 +7,7 @@
 import fs from "fs";
 import type { Session } from "../db";
 import { getDefaultBranch } from "../git";
-import { run } from "../tasks/gh";
+import { git as runGit } from "../git-exec";
 import { mergePolicy } from "../tasks/merge-policy";
 import { getProject } from "../projects";
 import {
@@ -24,7 +24,7 @@ export type WorktreeFate =
   | { action: "kept"; why: string; path: string };
 
 const git = (cwd: string, ...args: string[]) =>
-  run("git", args, cwd, 30000).then((out) => out.trim());
+  runGit(cwd, args, { timeout: 30000 }).then((out) => out.trim());
 
 // The main checkout a worktree belongs to.
 async function repoOf(worktree: string): Promise<string> {