@saadnvd1/agent-os 0.3.836 → 0.3.845

package/hooks/useAutoSave.test.ts

@@ -0,0 +1,116 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useAutoSave, type AutoSave } from "./useAutoSave";
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+afterEach(async () => {
+  await act(async () => root.unmount());
+  host.remove();
+  vi.useRealTimers();
+});
+
+// A server whose value the hook is given back as `saved`, like a query.
+async function mount(
+  save: (n: number) => Promise<unknown>,
+  notify = vi.fn(),
+  initial = 10
+) {
+  const box: { auto: AutoSave<number> } = {} as never;
+  let saved = initial;
+  const Probe = ({ value }: { value: number }) => {
+    box.auto = useAutoSave({
+      saved: value,
+      save: async (n) => {
+        await save(n);
+        saved = n;
+      },
+      notify,
+    });
+    return null;
+  };
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+  const render = () =>
+    act(async () => root.render(createElement(Probe, { value: saved })));
+  await render();
+  return { box, render, notify };
+}
+
+describe("useAutoSave", () => {
+  it("saves a new value and says Saved, then goes quiet", async () => {
+    vi.useFakeTimers();
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box, render } = await mount(save);
+    await act(async () => void (await box.auto.commit(20)));
+    await render();
+    expect(save).toHaveBeenCalledWith(20);
+    expect(box.auto.value).toBe(20);
+    expect(box.auto.status).toBe("saved");
+    await act(async () => void vi.advanceTimersByTime(2000));
+    expect(box.auto.status).toBe("idle");
+  });
+
+  it("sends nothing for the value it already has", async () => {
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box } = await mount(save);
+    await act(async () => void (await box.auto.commit(10)));
+    expect(save).not.toHaveBeenCalled();
+    expect(box.auto.status).toBe("idle");
+  });
+
+  it("shows the value while saving", async () => {
+    let finish!: () => void;
+    const save = vi.fn(() => new Promise<void>((r) => (finish = r)));
+    const { box } = await mount(save);
+    let done!: Promise<boolean>;
+    await act(async () => void (done = box.auto.commit(20)));
+    expect(box.auto.status).toBe("saving");
+    expect(box.auto.value).toBe(20);
+    await act(async () => {
+      finish();
+      await done;
+    });
+  });
+
+  it("rolls back to the saved value and tells the user when the server rejects", async () => {
+    const save = vi.fn().mockRejectedValue(new Error("Must be 50 or more"));
+    const { box, notify } = await mount(save);
+    let ok = true;
+    await act(async () => void (ok = await box.auto.commit(20)));
+    expect(ok).toBe(false);
+    expect(box.auto.value).toBe(10);
+    expect(box.auto.status).toBe("idle");
+    expect(notify).toHaveBeenCalledWith("Must be 50 or more");
+  });
+
+  it("undoes an undoable change by saving the old value back", async () => {
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box, render } = await mount(save);
+    await act(async () => void (await box.auto.commit(0, { undoable: true })));
+    await render();
+    expect(box.auto.status).toBe("undo");
+    await act(async () => void (await box.auto.undo()));
+    await render();
+    expect(save).toHaveBeenLastCalledWith(10);
+    expect(box.auto.value).toBe(10);
+    expect(box.auto.status).toBe("saved");
+  });
+
+  it("has nothing to undo after a plain change", async () => {
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box } = await mount(save);
+    await act(async () => void (await box.auto.commit(20)));
+    let ok = true;
+    await act(async () => void (ok = await box.auto.undo()));
+    expect(ok).toBe(false);
+    expect(save).toHaveBeenCalledTimes(1);
+  });
+});

package/hooks/useAutoSave.ts

@@ -0,0 +1,98 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+
+export type SaveStatus = "idle" | "saving" | "saved" | "undo";
+
+const SAVED_MS = 1800;
+const UNDO_MS = 7000;
+
+export interface AutoSave<T> {
+  // What to show: the value in flight while saving, else the saved one. A
+  // rejected save drops the in-flight value, so this is the saved one again.
+  value: T;
+  status: SaveStatus;
+  // Commit a new value. `undoable` keeps the previous one for Undo (large or
+  // destructive changes). Resolves false when the server rejected it.
+  commit: (next: T, opts?: { undoable?: boolean }) => Promise<boolean>;
+  undo: () => Promise<boolean>;
+}
+
+/**
+ * Save a setting the moment it changes. `saved` is the server's value
+ * (the query's); `save` sends one value and throws to reject it.
+ */
+export function useAutoSave<T>({
+  saved,
+  save,
+  equals = Object.is,
+  notify = (message) => toast.error(message),
+}: {
+  saved: T;
+  save: (next: T) => Promise<unknown>;
+  equals?: (a: T, b: T) => boolean;
+  notify?: (message: string) => void;
+}): AutoSave<T> {
+  const [pending, setPending] = useState<{ value: T } | null>(null);
+  const [status, setStatus] = useState<SaveStatus>("idle");
+  const previous = useRef<{ value: T } | null>(null);
+  const timer = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+  const seq = useRef(0);
+  const latest = useRef({ saved, save, equals, notify });
+  useEffect(() => {
+    latest.current = { saved, save, equals, notify };
+  });
+  useEffect(() => () => clearTimeout(timer.current), []);
+
+  const settle = useCallback((next: SaveStatus, ms: number) => {
+    setStatus(next);
+    clearTimeout(timer.current);
+    timer.current = setTimeout(() => setStatus("idle"), ms);
+  }, []);
+
+  const run = useCallback(
+    async (next: T, undoable: boolean, before: T) => {
+      const mine = ++seq.current;
+      clearTimeout(timer.current);
+      setPending({ value: next });
+      setStatus("saving");
+      try {
+        await latest.current.save(next);
+      } catch (err) {
+        if (mine === seq.current) {
+          setPending(null);
+          setStatus("idle");
+        }
+        latest.current.notify(
+          err instanceof Error ? err.message : "Couldn't save"
+        );
+        return false;
+      }
+      if (mine !== seq.current) return true;
+      setPending(null);
+      previous.current = undoable ? { value: before } : null;
+      settle(undoable ? "undo" : "saved", undoable ? UNDO_MS : SAVED_MS);
+      return true;
+    },
+    [settle]
+  );
+
+  const commit = useCallback(
+    (next: T, opts?: { undoable?: boolean }) => {
+      const { saved: current, equals: same } = latest.current;
+      if (same(next, current)) return Promise.resolve(true);
+      return run(next, !!opts?.undoable, current);
+    },
+    [run]
+  );
+
+  const undo = useCallback(async () => {
+    const back = previous.current;
+    if (!back) return false;
+    previous.current = null;
+    return run(back.value, false, latest.current.saved);
+  }, [run]);
+
+  return { value: pending ? pending.value : saved, status, commit, undo };
+}

package/lib/away/deploy.ts

@@ -33,6 +33,14 @@ export const HEALTH_GRACE_MS = 3 * 60 * 1000;
 export const GAP_MARGIN_MS = 10 * 60 * 1000;
 const DEFAULT_GAP_S = 3600;
 
+type HealthAnswer = {
+  ok: boolean;
+  why?: string;
+  startedAt?: number;
+  // The commit the running server was built from, when it says.
+  build?: string;
+};
+
 export interface DeployDeps {
   // When the deploy last restarted the server, in ms; null when unknown.
   restartedAt: (file: string) => number | null;
@@ -43,9 +51,7 @@ export interface DeployDeps {
   contains: (repo: string, tip: string, sha: string) => Promise<boolean>;
   // startedAt, when the server says when it started (AgentOS's
   // /api/health does), so a deploy that never restarted it is caught.
-  health: (
-    url: string
-  ) => Promise<{ ok: boolean; why?: string; startedAt?: number }>;
+  health: (url: string) => Promise<HealthAnswer>;
   // When GitHub made the merge commit, in ms (0 when unknown): the time a
   // restart has to come after. Not when AgentOS noticed the merge, which
   // can be after a restart that already took it.
@@ -78,18 +84,25 @@ async function contains(
   return ancestor();
 }
 
-async function health(
-  url: string
-): Promise<{ ok: boolean; why?: string; startedAt?: number }> {
+async function health(url: string): Promise<HealthAnswer> {
   try {
     const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
     if (!res.ok) return { ok: false, why: `HTTP ${res.status}` };
     const body = (await res.json().catch(() => null)) as {
       startedAt?: unknown;
+      build?: unknown;
     } | null;
     const startedAt =
       typeof body?.startedAt === "string" ? Date.parse(body.startedAt) : NaN;
-    return Number.isFinite(startedAt) ? { ok: true, startedAt } : { ok: true };
+    const build =
+      typeof body?.build === "string" && SHA.test(body.build)
+        ? body.build
+        : undefined;
+    return {
+      ok: true,
+      ...(Number.isFinite(startedAt) ? { startedAt } : {}),
+      ...(build ? { build } : {}),
+    };
   } catch (error) {
     return {
       ok: false,
@@ -161,6 +174,20 @@ async function judge(
     if (!config.health) return { state: "ok", detail: `${short} deployed` };
     const url = healthUrl(config.health);
     const answer = await deps.health(url);
+    // autodeploy's marker can name a build that isn't running (a rolled-back
+    // update); what the server says it runs decides.
+    if (
+      answer.ok &&
+      answer.build &&
+      !(await deps.contains(input.repo, answer.build, mergeSha))
+    ) {
+      if (input.now - deployed.at < HEALTH_GRACE_MS)
+        return { state: "pending" };
+      return {
+        state: "failed",
+        detail: `not deployed: the server is running ${answer.build.slice(0, 7)}, which doesn't have ${short}`,
+      };
+    }
     const merged =
       answer.ok && answer.startedAt !== undefined
         ? await deps.committedAt(input.repo, mergeSha)

package/lib/away/window-limits.ts

@@ -1,6 +1,8 @@
+import { SETTING_DEFAULTS } from "../settings/defaults";
+
 // The Away window's bounds, in minutes, for the server (./activity) and
 // the Settings form alike. Client-safe: no database.
-export const DEFAULT_WINDOW_MINUTES = 60;
+export const DEFAULT_WINDOW_MINUTES = SETTING_DEFAULTS.awayWindowMinutes;
 export const MIN_WINDOW_MINUTES = 10;
 export const MAX_WINDOW_MINUTES = 24 * 60;
 

package/lib/chat/refresh.ts

@@ -6,7 +6,7 @@
  * 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 two sizes at which chats and
+ * App-wide, in Settings → Context, 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).
  */
@@ -15,24 +15,28 @@ import { db } from "../db";
 import { effectiveModels } from "../models/config";
 import { type ModelRole } from "../models/roles";
 import { sessionRole } from "../models/session-role";
+import { SETTING_DEFAULTS } from "../settings/defaults";
 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";
 // Named for what it first did: compact chats idle past their cache.
 export const COMPACT_KEY = "chat.stale_compact_tokens";
-export const DEFAULT_ORCHESTRATOR_TOKENS = 200_000;
-export const DEFAULT_COMPACT_TOKENS = 150_000;
+export const DEFAULT_ORCHESTRATOR_TOKENS =
+  SETTING_DEFAULTS.fresh.orchestratorTokens;
+export const DEFAULT_COMPACT_TOKENS = SETTING_DEFAULTS.fresh.compactTokens;
 // 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 const DEFAULT_AUTO_COMPACT_TOKENS =
+  SETTING_DEFAULTS.fresh.autoCompactTokens;
 // 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 const DEFAULT_INTERACTIVE_AUTO_COMPACT_TOKENS =
+  SETTING_DEFAULTS.fresh.interactiveAutoCompactTokens;
 export { MIN_REFRESH_TOKENS, MAX_REFRESH_TOKENS } from "./refresh-limits";
 
 export interface RefreshSettings {
@@ -60,7 +64,7 @@ function read(key: string, fallback: number): number {
 export function refreshSettings(): RefreshSettings {
   return {
     orchestratorTokens: read(ORCHESTRATOR_KEY, DEFAULT_ORCHESTRATOR_TOKENS),
-    taskTokens: read(TASK_KEY, 0),
+    taskTokens: read(TASK_KEY, SETTING_DEFAULTS.fresh.taskTokens),
     compactTokens: read(COMPACT_KEY, DEFAULT_COMPACT_TOKENS),
     autoCompactTokens: read(AUTO_COMPACT_KEY, DEFAULT_AUTO_COMPACT_TOKENS),
     interactiveAutoCompactTokens: read(

package/lib/chat/stall-limits.ts

@@ -1,5 +1,7 @@
+import { SETTING_DEFAULTS } from "../settings/defaults";
+
 // The range the stall alert may take (lib/chat/stall), shared with the
 // settings form.
-export const DEFAULT_STALL_MINUTES = 8;
+export const DEFAULT_STALL_MINUTES = SETTING_DEFAULTS.stallMinutes;
 export const MIN_STALL_MINUTES = 2;
 export const MAX_STALL_MINUTES = 120;

package/lib/models/plan-fresh.ts

@@ -0,0 +1,61 @@
+/**
+ * Whether the plan file in a task's worktree was written by this task's
+ * planning turn. A plan committed to the base branch is checked out with the
+ * worktree and reads exactly like a fresh one, so it is refused: tracked by
+ * git, older than the worktree's plan folder, or identical to the base's copy.
+ */
+
+import fs from "fs";
+import path from "path";
+import { git } from "../git-exec";
+
+export type PlanVerdict =
+  { ok: true; text: string } | { ok: false; why: string };
+
+const PLAN_FILE = ".agentos/plan.md";
+
+export async function checkPlanFile(
+  worktree: string,
+  base: string | null | undefined
+): Promise<PlanVerdict | null> {
+  const file = path.join(worktree, PLAN_FILE);
+  let text: string;
+  let mtime: number;
+  try {
+    text = fs.readFileSync(file, "utf8");
+    mtime = fs.statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const quiet = (args: string[]) =>
+    git(worktree, args, { timeout: 15000 }).catch(() => null);
+  const tracked = await quiet(["ls-files", "--", PLAN_FILE]);
+  // Tracked and untouched is the base's copy; a tracked file the planner
+  // rewrote differs from HEAD and is its own.
+  if (
+    tracked?.trim() &&
+    (await quiet(["diff", "--quiet", "HEAD", "--", PLAN_FILE])) !== null
+  )
+    return { ok: false, why: "it is tracked by git and unchanged" };
+  // The plan folder's own .gitignore is written when the task starts.
+  const started = (() => {
+    try {
+      return fs.statSync(
+        path.join(worktree, path.dirname(PLAN_FILE), ".gitignore")
+      ).mtimeMs;
+    } catch {
+      return 0;
+    }
+  })();
+  if (started && mtime < started)
+    return { ok: false, why: "it was not written since the task started" };
+  if (base) {
+    for (const ref of [`origin/${base}`, base]) {
+      const theirs = await quiet(["show", `${ref}:${PLAN_FILE}`]);
+      if (theirs !== null && theirs === text)
+        return { ok: false, why: `it is identical to ${ref}'s copy` };
+      if (theirs !== null) break;
+    }
+  }
+  return { ok: true, text };
+}

package/lib/models/plan-step.ts

@@ -36,6 +36,7 @@ import {
 } from "../plans/features";
 import { advancePlan, setPlan } from "../db/session-parts";
 import { Owner } from "../owner";
+import { checkPlanFile } from "./plan-fresh";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -134,9 +135,13 @@ export function planNoteFor(
   file: string,
   next: string,
   again = "",
-  after = ""
+  after = "",
+  stale = ""
 ): string {
   let head = `Task "${s.name}": no plan file was written${again}; ${next}${after}.`;
+  // A plan file left over from the base branch is not this task's plan.
+  if (stale)
+    return `Task "${s.name}": no usable plan was written (the plan file is stale: ${stale})${again}; ${next}${after}.`;
   try {
     const text = fs.readFileSync(file, "utf8");
     const summary = planSummary(text);
@@ -153,7 +158,12 @@ export function planNoteFor(
 }
 
 // Tells the orchestrator that started a task its plan is written, once.
-function announcePlan(s: Session, ref: string | null, retried = false): void {
+function announcePlan(
+  s: Session,
+  ref: string | null,
+  retried = false,
+  stale = ""
+): void {
   // The machine that placed it announces the plan, from its own copy.
   if (s.plan_waits_for_caller) return;
   if (!orchestratorOf(s.started_by) && !s.held_by_device) return;
@@ -167,7 +177,7 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
     ? `implementing on ${ref}`
     : "waiting for approval, not implementing (approve_plan to go ahead, drop to reject)";
   const again = retried ? " (asked once more for it first)" : "";
-  const head = planNoteFor(s, file, next, again, ref ? " anyway" : "");
+  const head = planNoteFor(s, file, next, again, ref ? " anyway" : "", stale);
   if (s.held_by_device) {
     setPlan(db, s.id, { plan_note: head });
     return;
@@ -215,12 +225,14 @@ async function handOffToPieces(s: Session): Promise<void> {
   }
 }
 
-function readPlan(s: Session): string | null {
-  try {
-    return fs.readFileSync(path.join(s.worktree_path!, PLAN_FILE), "utf8");
-  } catch {
-    return null;
-  }
+// The plan this task's planning turn wrote: null when there is none, and
+// `stale` says why a file that is there was refused.
+async function readPlan(
+  s: Session
+): Promise<{ text: string | null; stale: string }> {
+  const v = await checkPlanFile(s.worktree_path!, s.base_branch);
+  if (!v) return { text: null, stale: "" };
+  return v.ok ? { text: v.text, stale: "" } : { text: null, stale: v.why };
 }
 
 export const implementMessageId = (sessionId: string) =>
@@ -243,7 +255,8 @@ async function startImplementing(
   from: "planning" | "awaiting",
   send: Send,
   amendment?: string,
-  retried = false
+  retried = false,
+  stale = ""
 ): Promise<string | null> {
   const sessionId = s.id;
   const routed = resolveRole("implement", {
@@ -251,7 +264,14 @@ async function startImplementing(
     override: taskOverride(s),
   });
   const id = implementMessageId(sessionId);
-  const planText = readPlan(s);
+  // Only the planning turn's own file is checked for being this task's: a
+  // plan waiting for approval was checked when its turn ended.
+  const planText =
+    from === "planning"
+      ? (await readPlan(s)).text
+      : fs.existsSync(path.join(s.worktree_path!, PLAN_FILE))
+        ? fs.readFileSync(path.join(s.worktree_path!, PLAN_FILE), "utf8")
+        : null;
   // The branch was cut when the task was created; the plan may have waited.
   const fresh = await refreshBase({
     name: s.name,
@@ -313,12 +333,7 @@ async function startImplementing(
     if (nothingOwn) return true;
     enqueue(sessionId, {
       id,
-      text: implementPrompt(
-        fs.existsSync(path.join(s.worktree_path!, PLAN_FILE)),
-        note,
-        piece,
-        baseNote
-      ),
+      text: implementPrompt(planText !== null, note, piece, baseNote),
       origin: { kind: "decision", label: "Plan step" },
     });
     return true;
@@ -326,7 +341,7 @@ async function startImplementing(
   if (!claimed) return null;
   if (from === "planning") {
     try {
-      announcePlan(s, routed.ref, retried);
+      announcePlan(s, routed.ref, retried, stale);
     } catch (e) {
       console.error("plan-done event failed:", e);
     }
@@ -411,7 +426,8 @@ export async function handoffAfterPlan(
   }
   // Mid-turn, the turn's own end decides.
   if (env.turnRunning?.()) return false;
-  if (!fs.existsSync(path.join(s.worktree_path, PLAN_FILE))) {
+  const found = await readPlan(s);
+  if (found.text === null) {
     const w = stateOf(sessionId);
     const now = (env.now ?? Date.now)();
     const limit = env.waitMs ?? PLAN_BACKGROUND_WAIT_MS;
@@ -458,7 +474,7 @@ export async function handoffAfterPlan(
   // A plan-only task never goes on by itself, in No approvals mode too: it
   // was asked to stop and show the plan. Pieces that couldn't be registered
   // always hold a plan-first one: building on a guess is the bug.
-  const planText = readPlan(s);
+  const planText = found.text;
   const pieceErrors =
     (planText && !s.plan_waits_for_caller
       ? splitOf(s, planText)?.errors
@@ -469,13 +485,14 @@ export async function handoffAfterPlan(
       "planning",
       send,
       undefined,
-      retried
+      retried,
+      found.stale
     );
     return ref !== null;
   }
   if (!advancePlan(db, sessionId, "planning", "awaiting")) return false;
   try {
-    announcePlan(s, null, retried);
+    announcePlan(s, null, retried, found.stale);
   } catch (e) {
     console.error("plan-done event failed:", e);
   }
@@ -490,8 +507,7 @@ export async function handoffAfterPlan(
   // The machine that placed a plan sends its own push.
   try {
     if (!s.plan_waits_for_caller) {
-      const text = readPlan(s);
-      const planned = text ? planFor(s, text) : null;
+      const planned = planText ? planFor(s, planText) : null;
       (await import("../notify/push/events")).pushPlanAwaiting(
         s.id,
         s.name,

package/lib/orchestrator/scope.ts

@@ -36,6 +36,9 @@ async function cardText(task: Session): Promise<string> {
   return task.task_prompt ?? task.name;
 }
 
+export const isTaskStatePath = (p: string) =>
+  p === ".agentos" || p.startsWith(".agentos/");
+
 export async function checkScope(input: {
   workspaceId: string;
   task: Session;
@@ -53,6 +56,13 @@ export async function checkScope(input: {
     // Claimed before the first await: written in the same tick as the
     // review's verdict, so no review call sees neither.
     putCheck({ ...base, status: "running", detail: null });
+    const taskState = input.files.filter((f) => isTaskStatePath(f.path));
+    if (taskState.length)
+      return putCheck({
+        ...base,
+        status: "block",
+        detail: `Commits task state under .agentos/ (${taskState.map((f) => f.path).join(", ")}); the plan folder is never part of a change.`,
+      });
     const amended = input.amendments?.length
       ? `\n\nScope changes recorded since the task started, oldest first; they win over the card, and a later one over an earlier one:\n${fence("amendments", input.amendments.map((a, i) => `${i + 1}. ${a}`).join("\n"))}`
       : "";

package/lib/settings/defaults.ts

@@ -0,0 +1,27 @@
+// Every setting's default, in one pure module the server's constants and the
+// settings UI both import, so the two can't disagree (lib/settings/defaults.test).
+// Context sizes are in tokens; 0 is off.
+
+export const SETTING_DEFAULTS = {
+  fresh: {
+    orchestratorTokens: 200_000,
+    taskTokens: 0,
+    compactTokens: 150_000,
+    autoCompactTokens: 300_000,
+    interactiveAutoCompactTokens: 300_000,
+  },
+  // What a switch turns on with when the default is off.
+  freshOnValue: 200_000,
+  stallMinutes: 8,
+  awayWindowMinutes: 60,
+  // Off by default; what the switch turns on with.
+  taskLimitOn: 3,
+  sweepDays: 7,
+} as const;
+
+export type FreshKey = keyof typeof SETTING_DEFAULTS.fresh;
+
+export function freshOnValue(key: FreshKey): number {
+  const d = SETTING_DEFAULTS.fresh[key];
+  return d > 0 ? d : SETTING_DEFAULTS.freshOnValue;
+}

package/lib/settings/parse.ts

@@ -0,0 +1,17 @@
+// A typed number, checked before anything is sent. An invalid one stays in
+// the field with this message; nothing reaches the server.
+export function parseSettingNumber(
+  text: string,
+  { min, max, integer = true }: { min: number; max?: number; integer?: boolean }
+): { value: number } | { error: string } {
+  const t = text.trim();
+  const n = Number(t);
+  const range = max === undefined ? `${min} or more` : `from ${min} to ${max}`;
+  const msg = integer
+    ? `Enter a whole number ${range}.`
+    : `Enter a number ${range}.`;
+  if (!t || !Number.isFinite(n)) return { error: msg };
+  if (integer && !Number.isInteger(n)) return { error: msg };
+  if (n < min || (max !== undefined && n > max)) return { error: msg };
+  return { value: n };
+}

package/lib/settings-url.ts

@@ -8,6 +8,7 @@ export const SETTINGS_SECTIONS = [
   "merging",
   "approvals",
   "workspaces",
+  "context",
   "models",
   "agent-roles",
   "devices",

package/lib/updates/banner.ts

@@ -94,6 +94,7 @@ export type UpdateRefusal =
   | "up_to_date"
   | "unknown"
   | "no_restart"
+  | "managed"
   | "disk"
   | "forbidden";
 
@@ -173,6 +174,7 @@ export function bannerState({
       return "updated";
   }
   if (view.pending) return "pending";
+  if (view.canUpdate.code === "managed") return "hidden";
   if (
     view.available &&
     view.bannerEnabled &&