@saadnvd1/agent-os 0.3.482 → 0.3.483

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,8 +356,8 @@ 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

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/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/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).

package/lib/usage/turns.ts

@@ -91,10 +91,16 @@ export function recordTurn(
   return totals;
 }
 
+// When a compaction ran: "mid_turn" is the agent's own, at its auto-compact
+// window, while it worked; the rest happen between turns.
+export type CompactionPhase = "mid_turn" | "between_turns";
+export const compactionPhase = (trigger: string): CompactionPhase =>
+  trigger === "auto" ? "mid_turn" : "between_turns";
+
 // Records one compaction: who ran it ("auto" is the agent's own, at its
 // auto-compact window; "threshold" and "stale" are AgentOS's before a
-// message; "manual" is a /compact someone typed), and the context before
-// and after when the agent said.
+// message; "manual" is a /compact someone typed), which phase that was,
+// and the context before and after when the agent said.
 export function recordCompaction(
   session: Pick<Session, "id" | "name" | "workspace_id">,
   c: { trigger: string; before?: number; after?: number },
@@ -106,14 +112,15 @@ export function recordCompaction(
     | { name: string; workspace_id: string | null }
     | undefined;
   db.prepare(
-    `INSERT INTO chat_compactions (session_id, session_name, workspace_id, at, trigger, before_tokens, after_tokens)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`
+    `INSERT INTO chat_compactions (session_id, session_name, workspace_id, at, trigger, phase, before_tokens, after_tokens)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     session.id,
     current?.name ?? session.name,
     current?.workspace_id ?? session.workspace_id,
     at,
     c.trigger,
+    compactionPhase(c.trigger),
     c.before ?? null,
     c.after ?? null
   );

package/package.json

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