@saadnvd1/agent-os 0.3.575 → 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/away/run.ts

@@ -55,6 +55,7 @@ import {
 import { checkDeploy } from "./deploy";
 import { buildAwayReport, phoneSummary, reportMarkdown } from "./report";
 import { awayOnLine } from "./brief";
+import { shutFinishedTaskSimulators } from "../simulator";
 
 const PHONE_SOURCE = "away";
 const PHONE_LINES = 8;
@@ -582,6 +583,9 @@ export function awayTick(now = Date.now()): void {
         console.error(`[away] sweep of ${workspaceId}:`, error);
       }
     }
+    await shutFinishedTaskSimulators().catch((error) =>
+      console.error("[away] simulator sweep:", error)
+    );
     // Ended meanwhile: the report's summary says what's waiting.
     const still = activeAway();
     if (still?.id === away.id) notifyBatch(still, Date.now());

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/lib/sessions/end.ts

@@ -2,10 +2,11 @@ import type { Session } from "../db";
 import { stopChat } from "../chat/runner";
 import { waitForExit } from "../chat/worker/client";
 import { endTmuxSession } from "../tmux/end";
-import { releaseOnEnd } from "../simulator";
+import { releaseOnEnd, shutTaskSimulators } from "../simulator";
 import { forgetPlanWait } from "../models/plan-step";
 
-type Agent = Pick<Session, "id" | "host_id" | "tmux_name">;
+type Agent = Pick<Session, "id" | "host_id" | "tmux_name"> &
+  Partial<Pick<Session, "worktree_path" | "branch_name">>;
 
 // A session's agent, ended: its chat worker, and its own tmux session (a
 // chat session can still own one). The one call that delete, done, drop and
@@ -15,6 +16,8 @@ export async function endSessionAgent(s: Agent): Promise<void> {
   stopChat(s.id);
   // The task's simulator goes with it; no row, no work.
   releaseOnEnd(s.id, { remove: true });
+  // And any the project's own scripts booted for it; shut down only.
+  shutTaskSimulators(s);
   void waitForExit(s.id).catch(() => {});
   await endTmuxSession(s.host_id, s.tmux_name);
 }

package/lib/simulator/index.ts

@@ -60,6 +60,7 @@ export class SimulatorError extends Error {
 }
 
 export { simulatorAvailable };
+export { shutTaskSimulators, shutFinishedTaskSimulators } from "./task-devices";
 
 const session = (id: string) =>
   db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as

package/lib/simulator/simctl.ts

@@ -142,6 +142,16 @@ export async function shutdownDevice(device: {
   }
 }
 
+// Shut down only, never delete or erase. Also used for devices a project's
+// own scripts made, matched to a finished task by name (task-devices.ts).
+export async function shutdownByUdid(udid: string): Promise<void> {
+  try {
+    await run(["shutdown", udid]);
+  } catch (error) {
+    if (!/current state: Shutdown/i.test(String(error))) throw error;
+  }
+}
+
 export async function deleteDevice(device: {
   udid: string;
   name: string;

package/lib/simulator/task-devices.ts

@@ -0,0 +1,160 @@
+/**
+ * Booted simulators that belong to a task, shut down when it ends. Two naming
+ * schemes: AgentOS's own (`aos-<instance>-<task id>`, from `aos sim`) and the
+ * agentos-mobile project's (`agentos-<branch>-<worktree hash>`, from its
+ * `npm run sim`). Shut down only: nothing here deletes or erases a device.
+ */
+
+import { createHash } from "crypto";
+import fs from "fs";
+import { db, type Session } from "../db";
+import { isRemoteHost } from "../hosts";
+import { simulatorAvailable } from "./available";
+import {
+  deviceNameFor,
+  listDevices,
+  shutdownByUdid,
+  type SimDevice,
+} from "./simctl";
+
+// Same as agentos-mobile's scripts/lib/sim-helpers.mjs (slug, simName); the
+// two must stay in step.
+export const simSlug = (text: string) =>
+  text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+
+export const projectSimName = (
+  branch: string | null | undefined,
+  worktreePath: string
+) =>
+  `agentos-${simSlug(branch || "detached") || "detached"}-${createHash("sha1")
+    .update(worktreePath)
+    .digest("hex")
+    .slice(0, 6)}`;
+
+export const FINISHED = new Set(["merged", "dropped", "done"]);
+
+export interface TaskRef {
+  id: string;
+  branch_name: string | null;
+  worktree_path: string | null;
+  task_status?: string | null;
+}
+
+// The script resolves its worktree through symlinks; the row may not.
+export function pathVariants(p: string | null): string[] {
+  if (!p) return [];
+  try {
+    return [...new Set([p, fs.realpathSync(p)])];
+  } catch {
+    return [p];
+  }
+}
+
+export function taskDeviceNames(
+  t: Pick<TaskRef, "id" | "branch_name">,
+  paths: string[]
+): string[] {
+  return [
+    ...new Set([
+      deviceNameFor(t.id),
+      ...paths.map((p) => projectSimName(t.branch_name, p)),
+    ]),
+  ];
+}
+
+const running = (d: SimDevice) => d.state === "Booted" || d.state === "Booting";
+
+// Running devices whose every matching task is finished: a task re-run on the
+// same branch and worktree keeps its device, and unmatched ones are not ours.
+export function planFinishedShutdowns(
+  devices: SimDevice[],
+  tasks: (TaskRef & { paths?: string[] })[]
+): SimDevice[] {
+  const owners = new Map<string, boolean[]>();
+  for (const t of tasks) {
+    const finished = FINISHED.has(t.task_status ?? "");
+    const paths = t.paths ?? pathVariants(t.worktree_path);
+    for (const name of taskDeviceNames(t, paths))
+      owners.set(name, [...(owners.get(name) ?? []), finished]);
+  }
+  return devices.filter((d) => {
+    const o = owners.get(d.name);
+    return running(d) && !!o && o.every(Boolean);
+  });
+}
+
+const enabled = () =>
+  simulatorAvailable() && process.env.AGENTOS_SIM_SHUTDOWN !== "off";
+
+async function shutAll(devices: SimDevice[], why: string): Promise<number> {
+  let n = 0;
+  for (const d of devices) {
+    try {
+      await shutdownByUdid(d.udid);
+      n++;
+      console.log(`[simulator] shut down ${d.name}: ${why}`);
+    } catch (error) {
+      console.error(`[simulator] shutdown ${d.name}:`, error);
+    }
+  }
+  return n;
+}
+
+// For a task that is ending. Never blocks and never throws into the cleanup.
+export function shutTaskSimulators(
+  s: Pick<Session, "id" | "host_id"> &
+    Partial<Pick<Session, "branch_name" | "worktree_path">>
+): void {
+  try {
+    if (!enabled() || isRemoteHost(s.host_id)) return;
+    // Before the caller removes the worktree, which realpath needs.
+    const names = new Set(
+      taskDeviceNames(
+        { id: s.id, branch_name: s.branch_name ?? null },
+        pathVariants(s.worktree_path ?? null)
+      )
+    );
+    void listDevices()
+      .then((devices) =>
+        shutAll(
+          devices.filter((d) => running(d) && names.has(d.name)),
+          "its task ended"
+        )
+      )
+      .catch((error) => console.error("[simulator] list:", error));
+  } catch (error) {
+    console.error("[simulator] shutTaskSimulators:", error);
+  }
+}
+
+let sweeping = false;
+
+// Shuts down booted simulators whose task is merged, dropped or done.
+export async function shutFinishedTaskSimulators(): Promise<number> {
+  if (!enabled() || sweeping) return 0;
+  sweeping = true;
+  try {
+    const devices = (await listDevices()).filter(
+      (d) =>
+        (running(d) && d.name.startsWith("agentos-")) ||
+        (running(d) && d.name.startsWith("aos-"))
+    );
+    if (devices.length === 0) return 0;
+    const tasks = (
+      db
+        .prepare(
+          `SELECT id, branch_name, worktree_path, task_status, host_id
+           FROM sessions WHERE task_status IS NOT NULL`
+        )
+        .all() as (TaskRef & { host_id: string })[]
+    ).filter((t) => !isRemoteHost(t.host_id));
+    const stale = planFinishedShutdowns(devices, tasks);
+    return await shutAll(stale, "its task is finished");
+  } finally {
+    sweeping = false;
+  }
+}

package/package.json

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

package/server.ts

@@ -79,7 +79,7 @@ import { claimAgentosEnv } from "./lib/agents/self-env";
 import { wslNotes, wslVersion } from "./lib/wsl";
 import { getAllProjects } from "./lib/projects";
 import { isRemoteHost } from "./lib/hosts";
-import { sweepSimulators } from "./lib/simulator";
+import { shutFinishedTaskSimulators, sweepSimulators } from "./lib/simulator";
 
 const dev = process.env.NODE_ENV !== "production";
 const hostname = "127.0.0.1";
@@ -385,6 +385,7 @@ app.prepare().then(async () => {
     sweepingSims = true;
     try {
       await sweepSimulators();
+      await shutFinishedTaskSimulators();
     } catch (error) {
       console.error("Sweeping simulators failed:", error);
     } finally {