@saadnvd1/agent-os 0.3.576 → 0.3.577

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: between turns (lib/chat/stale) and mid-turn, by the agent itself;
+// compact: between turns (lib/chat/stale) and mid-turn, by the agent itself
+// (one size for tasks, one for a person's own sessions);
 // 0 for never.
 export async function GET() {
   return NextResponse.json(refreshSettings());
@@ -18,6 +19,7 @@ export async function PUT(request: NextRequest) {
       // Its name before it also set the agents' own auto-compact.
       compactTokens: body.compactTokens ?? body.staleCompactTokens,
       autoCompactTokens: body.autoCompactTokens,
+      interactiveAutoCompactTokens: body.interactiveAutoCompactTokens,
     });
     return NextResponse.json(refreshSettings());
   } catch (error) {

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}:${data.autoCompactTokens}`}
+      key={`${data.orchestratorTokens}:${data.taskTokens}:${data.compactTokens}:${data.autoCompactTokens}:${data.interactiveAutoCompactTokens}`}
       saved={data}
     />
   );
@@ -31,14 +31,20 @@ function Form({ saved }: { saved: RefreshSettings }) {
   const task = useThreshold(saved.taskTokens, 200);
   const compact = useThreshold(saved.compactTokens, 150);
   const midTurn = useThreshold(saved.autoCompactTokens, 300);
+  const interactive = useThreshold(saved.interactiveAutoCompactTokens, 200);
   const error =
-    orchestrator.error ?? task.error ?? compact.error ?? midTurn.error;
+    orchestrator.error ??
+    task.error ??
+    compact.error ??
+    midTurn.error ??
+    interactive.error;
   const dirty =
     !error &&
     (orchestrator.tokens !== saved.orchestratorTokens ||
       task.tokens !== saved.taskTokens ||
       compact.tokens !== saved.compactTokens ||
-      midTurn.tokens !== saved.autoCompactTokens);
+      midTurn.tokens !== saved.autoCompactTokens ||
+      interactive.tokens !== saved.interactiveAutoCompactTokens);
 
   return (
     <form
@@ -51,6 +57,7 @@ function Form({ saved }: { saved: RefreshSettings }) {
             taskTokens: task.tokens,
             compactTokens: compact.tokens,
             autoCompactTokens: midTurn.tokens,
+            interactiveAutoCompactTokens: interactive.tokens,
           },
           {
             onSuccess: () => toast.success("Context settings saved"),
@@ -77,12 +84,19 @@ function Form({ saved }: { saved: RefreshSettings }) {
         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.
+        Your own sessions, in a chat or a terminal, have their own mid-turn
+        size; a terminal can&apos;t be compacted between turns, so that is the
+        only compaction it gets. Orchestrators start fresh instead.
       </p>
       <ThresholdRow
-        label="Mid-turn"
+        label="Mid-turn, tasks"
         field={midTurn}
-        switchLabel="Let the agent compact itself mid-turn"
+        switchLabel="Let a task's agent compact itself mid-turn"
+      />
+      <ThresholdRow
+        label="Mid-turn, your sessions"
+        field={interactive}
+        switchLabel="Let your own sessions compact themselves mid-turn"
       />
       <ThresholdRow
         label="Between turns"

package/lib/agents/launch.ts

@@ -12,6 +12,7 @@ import { BUS_BRIEF } from "./brief";
 import { selfUrl } from "./self-env";
 import { autoCompactEnv } from "../chat/refresh";
 import { subagentEnv } from "../models/subagents";
+import { COMPACT_BRIEF } from "../chat/working-state";
 import { CLAUDE_STATUS_SETTINGS_FLAG } from "../program-status/claude-flag";
 import {
   sessionProjectEnv,
@@ -28,7 +29,7 @@ export const BUS_BRIEF_FILE = path.join(
 
 export function ensureBusBrief(): void {
   fs.mkdirSync(path.dirname(BUS_BRIEF_FILE), { recursive: true });
-  fs.writeFileSync(BUS_BRIEF_FILE, BUS_BRIEF);
+  fs.writeFileSync(BUS_BRIEF_FILE, `${BUS_BRIEF}\n\n${COMPACT_BRIEF}`);
 }
 
 // Who a session is and how it reaches AgentOS, set in its tmux environment so

package/lib/chat/refresh.ts

@@ -13,6 +13,7 @@
 
 import { db } from "../db";
 import { effectiveModels } from "../models/config";
+import { sessionRole, type ModelRole } from "../models/roles";
 import { MAX_REFRESH_TOKENS, MIN_REFRESH_TOKENS } from "./refresh-limits";
 
 export const ORCHESTRATOR_KEY = "orchestrator.refresh_tokens";
@@ -25,6 +26,12 @@ export const DEFAULT_COMPACT_TOKENS = 150_000;
 // 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;
+// The same window for a person's own (interactive) sessions, which run long
+// on the biggest model. 300k (DEFAULT_AUTO_COMPACT_TOKENS) was its value
+// before it had its own setting: set it back to restore that.
+export const INTERACTIVE_AUTO_COMPACT_KEY =
+  "chat.interactive_auto_compact_tokens";
+export const DEFAULT_INTERACTIVE_AUTO_COMPACT_TOKENS = 300_000;
 export { MIN_REFRESH_TOKENS, MAX_REFRESH_TOKENS } from "./refresh-limits";
 
 export interface RefreshSettings {
@@ -37,6 +44,8 @@ export interface RefreshSettings {
   // Mid-turn: Claude Code's own auto-compact window for a chat's or task's
   // agent. 0 is off.
   autoCompactTokens: number;
+  // The same, for interactive sessions. 0 is off.
+  interactiveAutoCompactTokens: number;
 }
 
 function read(key: string, fallback: number): number {
@@ -53,6 +62,10 @@ export function refreshSettings(): RefreshSettings {
     taskTokens: read(TASK_KEY, 0),
     compactTokens: read(COMPACT_KEY, DEFAULT_COMPACT_TOKENS),
     autoCompactTokens: read(AUTO_COMPACT_KEY, DEFAULT_AUTO_COMPACT_TOKENS),
+    interactiveAutoCompactTokens: read(
+      INTERACTIVE_AUTO_COMPACT_KEY,
+      DEFAULT_INTERACTIVE_AUTO_COMPACT_TOKENS
+    ),
   };
 }
 
@@ -92,6 +105,11 @@ export function setRefreshSettings(input: Partial<RefreshSettings>): void {
       AUTO_COMPACT_KEY,
       checkRefreshTokens(input.autoCompactTokens),
     ]);
+  if (input.interactiveAutoCompactTokens !== undefined)
+    checked.push([
+      INTERACTIVE_AUTO_COMPACT_KEY,
+      checkRefreshTokens(input.interactiveAutoCompactTokens),
+    ]);
   db.transaction(() => {
     for (const [key, n] of checked) put.run(key, String(n));
   })();
@@ -121,22 +139,46 @@ export function compactThreshold(
   return window ? Math.min(wanted, window) : wanted;
 }
 
+// Claude Code's own auto-compact window for an agent, before the provider's
+// adjustment; 0 is none. A person's session has its own window, in a chat
+// or a terminal alike (a terminal can't be compacted between turns, so this
+// is the only compaction it gets). An orchestrator starts over from its
+// brief at its own threshold instead, since a summary would carry what it
+// read from tasks and CI without its untrusted fence.
+export function autoCompactTokensFor(
+  role: ModelRole,
+  s: RefreshSettings
+): number {
+  if (role === "orchestrator") return 0;
+  return role === "interactive"
+    ? s.interactiveAutoCompactTokens
+    : s.autoCompactTokens;
+}
+
 // What an agent is launched with so it compacts itself at the threshold.
-// Not an orchestrator: it starts over from its brief at its own threshold
-// instead, since a summary would carry what it read from tasks and CI
-// without its untrusted fence. Nothing when it's off, so a window set in
-// the user's own environment still applies.
+// Nothing when it's off, so a window set in the user's own environment
+// still applies.
 export function autoCompactEnv(sessionId: string): Record<string, string> {
   const row = db
-    .prepare(`SELECT role, model_provider FROM sessions WHERE id = ?`)
+    .prepare(
+      `SELECT role, task_status, plan_phase, started_by, model_provider
+       FROM sessions WHERE id = ?`
+    )
     .get(sessionId) as
-    | { role: string | null; model_provider: string | null }
+    | {
+        role: string | null;
+        task_status: string | null;
+        plan_phase: string | null;
+        started_by: string | null;
+        model_provider: string | null;
+      }
     | undefined;
-  const tokens = refreshSettings().autoCompactTokens;
-  if (row?.role === "orchestrator" || tokens <= 0) return {};
+  if (!row) return {};
+  const tokens = autoCompactTokensFor(sessionRole(row), refreshSettings());
+  if (tokens <= 0) return {};
   const window = compactThreshold(
     Math.max(AUTO_COMPACT_MIN, tokens),
-    row?.model_provider
+    row.model_provider
   );
   return { [AUTO_COMPACT_ENV]: String(window) };
 }

package/lib/orchestrator/testing.ts

@@ -36,11 +36,11 @@ export function seedSession(opts: {
 export function seedWorkspace(name = `ws-${randomUUID().slice(0, 6)}`) {
   const workspace = createWorkspace(name);
   const app = createProject({
-    name: `app-${randomUUID().slice(0, 4)}`,
+    name: `app-${randomUUID().slice(0, 8)}`,
     workingDirectory: "/tmp/app",
   });
   const api = createProject({
-    name: `api-${randomUUID().slice(0, 4)}`,
+    name: `api-${randomUUID().slice(0, 8)}`,
     workingDirectory: "/tmp/api",
   });
   setProjectWorkspace(app.id, workspace.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.576",
+  "version": "0.3.577",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"