@saadnvd1/agent-os 0.3.836 → 0.3.845

package/lib/updates/run.ts

@@ -85,6 +85,8 @@ export interface RunDeps {
   freeBytes: () => number | null;
   /** True when scripts/autodeploy deploys this checkout. */
   managed: () => boolean;
+  /** True while scripts/autodeploy is deploying (its lock directory exists). */
+  deployLocked: () => boolean;
   /** What a restart would interrupt, as short labels; empty when nothing. */
   busy: () => Promise<string[]>;
   /** The database the runner backs up first, and where to. */
@@ -214,6 +216,7 @@ export function realRunDeps(): RunDeps {
         return false;
       }
     },
+    deployLocked: () => fs.existsSync(agentosHome("autodeploy", "lock")),
     busy: busyLabels,
     dbFile: path.resolve(dbPath()),
     backupDir: agentosHome("backups"),
@@ -355,6 +358,12 @@ export async function preflight(
       error:
         "AgentOS isn't running from a git checkout, so it can't update itself.",
     };
+  if (deps.managed() || deps.deployLocked())
+    return {
+      code: "managed",
+      error:
+        "This machine is updated by its own deploy job, so updating from here would race it. It deploys new versions by itself.",
+    };
   const run = readRun(deps);
   if (run && isActivePhase(run.phase))
     return {

package/lib/updates/view.ts

@@ -1,7 +1,7 @@
 // The /api/updates payload: the cached check, the run, what's pending,
 // whether the caller may start an update, and what automatic updates are doing.
 
-import { isActivePhase, type UpdateView } from "./banner";
+import { isActivePhase, type UpdateRun, type UpdateView } from "./banner";
 import { cachedCheck, checkForUpdate, reconcile } from "./check";
 import {
   autoView,
@@ -26,6 +26,27 @@ const redact = (lines: string[]) =>
       .replace(/\b[A-Za-z0-9_-]{32,}\b/g, "***")
   );
 
+/**
+ * A failed or rolled-back run stops mattering once the running build has the
+ * commit it tried (autodeploy, or someone, put it or something newer there).
+ */
+export async function runSuperseded(
+  run: UpdateRun | null,
+  deps: Pick<RunDeps, "git" | "buildId">
+): Promise<boolean> {
+  if (!run?.to || (run.phase !== "failed" && run.phase !== "rolled_back"))
+    return false;
+  const build = deps.buildId();
+  if (!/^[0-9a-f]{7,40}$/.test(build)) return false;
+  if (build === run.to) return true;
+  try {
+    await deps.git(["merge-base", "--is-ancestor", run.to, build]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function updateView(
   { mayUpdate }: { mayUpdate: boolean },
   deps: RunDeps = realRunDeps()
@@ -45,11 +66,12 @@ export async function updateView(
       .result;
   check = await reconcile(check, deps.check);
   // The log can carry paths and remote URLs; only a device that may update sees it.
-  const run =
-    stored &&
-    (stored.phase === "failed" ||
-      stored.phase === "built" ||
-      stored.phase === "rolled_back")
+  const run = (await runSuperseded(stored, deps))
+    ? null
+    : stored &&
+        (stored.phase === "failed" ||
+          stored.phase === "built" ||
+          stored.phase === "rolled_back")
       ? {
           ...stored,
           log: mayUpdate

package/lib/worktree-deps/paths.ts

@@ -22,13 +22,16 @@ export async function realExisting(p: string): Promise<string> {
 
 export const STAGING_SUFFIX = ".aos-partial";
 
-const EXCLUDE_LINE = `*${STAGING_SUFFIX}`;
+const STAGING_LINE = `*${STAGING_SUFFIX}`;
 
 // Staging dirs (`node_modules.aos-partial`) sit beside their target, where git
 // would list them as untracked work. Written once to the repo's shared
 // info/exclude, so it covers every worktree and no .gitignore is touched.
 // Best effort: outside a repository there is nothing to ignore it in.
-export async function ignoreStaging(dir: string): Promise<void> {
+export const ignoreStaging = (dir: string) => addExcludes(dir, [STAGING_LINE]);
+
+// Lines written once to the shared info/exclude of the repo `dir` is in.
+export async function addExcludes(dir: string, lines: string[]): Promise<void> {
   try {
     const common = (
       await git(dir, ["rev-parse", "--git-common-dir"], { timeout: 5000 })
@@ -36,10 +39,12 @@ export async function ignoreStaging(dir: string): Promise<void> {
     if (!common) return;
     const file = path.join(path.resolve(dir, common), "info", "exclude");
     const current = await fs.promises.readFile(file, "utf8").catch(() => "");
-    if (current.split(/\r?\n/).some((l) => l.trim() === EXCLUDE_LINE)) return;
+    const have = new Set(current.split(/\r?\n/).map((l) => l.trim()));
+    const missing = lines.filter((l) => !have.has(l));
+    if (!missing.length) return;
     await fs.promises.mkdir(path.dirname(file), { recursive: true });
     const lead = current && !current.endsWith("\n") ? "\n" : "";
-    await fs.promises.appendFile(file, `${lead}${EXCLUDE_LINE}\n`);
+    await fs.promises.appendFile(file, `${lead}${missing.join("\n")}\n`);
   } catch {
     // never fails a setup
   }

package/lib/worktree-sweep/limits.ts

@@ -0,0 +1,3 @@
+// The sweep's day range, client-safe: the server (./settings) and the
+// Settings box share it.
+export const MAX_SWEEP_DAYS = 365;

package/lib/worktree-sweep/settings.ts

@@ -5,10 +5,12 @@
 
 import { z } from "zod";
 import { db } from "../db";
+import { SETTING_DEFAULTS } from "../settings/defaults";
+import { MAX_SWEEP_DAYS } from "./limits";
 import type { ResolvedDays } from "./types";
 
-export const DEFAULT_SWEEP_DAYS = 7;
-export const MAX_SWEEP_DAYS = 365;
+export const DEFAULT_SWEEP_DAYS = SETTING_DEFAULTS.sweepDays;
+export { MAX_SWEEP_DAYS } from "./limits";
 
 const GLOBAL_KEY = "worktree_sweep";
 const projectKey = (projectId: string) => `worktree_sweep.project.${projectId}`;

package/lib/worktrees.ts

@@ -17,6 +17,7 @@ import { refuseRealStateUnderTest } from "./test-home-guard";
 import { installWorktreeHooks } from "./worktree-hooks";
 import { gitResult, isGitError, worktreeList } from "./git-exec";
 import { addWorktree } from "./worktree-add";
+import { addExcludes } from "./worktree-deps/paths";
 import {
   markRemoving,
   removalKey,
@@ -172,6 +173,8 @@ export async function createWorktree(
           err
         )
       );
+      // Task state (the plan) must never be committed from a worktree.
+      await addExcludes(worktreePath, [".agentos/"]);
       return {
         worktreePath,
         branchName,

package/package.json

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

package/scripts/autodeploy

@@ -33,6 +33,17 @@ mkdir -p "$state"
 # updates stand aside (lib/updates/run.ts managedByAutodeploy). Before the
 # lock: a long deploy still counts as managing it.
 touch "$state/heartbeat"
+# An in-app update (lib/updates/run.ts) in progress owns this checkout: its
+# pull would meet ours mid-way. Its state file is rewritten every 15 seconds,
+# so an old one is a run that died. Quiet exit; the next minute retries.
+for f in "${AGENTOS_UPDATE_STATE:-}" "${DB_PATH:+$(dirname "$DB_PATH")/agent-os-update.json}" \
+  "$HOME/.agent-os/agent-os-update.json" "$PWD/agent-os-update.json"; do
+  [ -n "$f" ] && [ -f "$f" ] || continue
+  [ -z "$(find "$f" -maxdepth 0 -mmin +30)" ] || continue
+  if grep -Eq '"phase" *: *"(starting|backing_up|pulling|installing|building|restarting|verifying|rolling_back)"' "$f"; then
+    exit 0
+  fi
+done
 # A lock older than 30 minutes is from a run that died.
 for lock in lock publish.lock; do
   if [ -d "$state/$lock" ] && [ -n "$(find "$state/$lock" -maxdepth 0 -mmin +30)" ]; then

package/scripts/autodeploy.test.ts

@@ -241,3 +241,33 @@ describe("autodeploy publish", () => {
     expect(fs.existsSync(lock)).toBe(false);
   });
 });
+
+describe("autodeploy and an in-app update", () => {
+  it("exits quietly while an update is in progress, and deploys once it's done", () => {
+    const t = setup();
+    t.commit("a");
+    fs.mkdirSync(path.join(t.home, ".agent-os"), { recursive: true });
+    const file = path.join(t.home, ".agent-os/agent-os-update.json");
+    fs.writeFileSync(file, JSON.stringify({ id: "r", phase: "pulling" }));
+    expect(t.run()).toBe("");
+    expect(t.restarts()).toBe(0);
+    expect(fs.existsSync(path.join(t.state, "deployed"))).toBe(false);
+    // The heartbeat still says this machine is managed.
+    expect(fs.existsSync(path.join(t.state, "heartbeat"))).toBe(true);
+    fs.writeFileSync(file, JSON.stringify({ id: "r", phase: "done" }));
+    t.run();
+    expect(t.restarts()).toBe(1);
+  });
+
+  it("ignores the state file of a run that died long ago", () => {
+    const t = setup();
+    t.commit("a");
+    fs.mkdirSync(path.join(t.home, ".agent-os"), { recursive: true });
+    const file = path.join(t.home, ".agent-os/agent-os-update.json");
+    fs.writeFileSync(file, JSON.stringify({ id: "r", phase: "building" }));
+    const old = new Date(Date.now() - 60 * 60_000);
+    fs.utimesSync(file, old, old);
+    t.run();
+    expect(t.restarts()).toBe(1);
+  });
+});

package/scripts/lib/update-verify.mjs

@@ -39,6 +39,9 @@ async function health(base, expect) {
   if (expect && build && build !== expect && !build.startsWith("v"))
     return {
       ok: false,
+      wrongBuild: true,
+      build,
+      startedAt,
       why: `it is running ${String(build).slice(0, 7)}, not ${expect.slice(0, 7)}`,
     };
   if (migrations && migrations.applied < migrations.known)
@@ -77,6 +80,14 @@ export async function verifyServer({ port, expect, env = process.env }) {
   for (let i = 0; i < checks; i++) {
     await sleep(every);
     const again = await health(base, expect);
+    // The expected build was up; now another one answers. Something else
+    // (a deploy job) restarted it: not a crash, and not ours to roll back over.
+    if (!again.ok && again.wrongBuild)
+      return {
+        ok: false,
+        otherRestart: true,
+        why: `something else restarted it into ${String(again.build).slice(0, 7)}, not ${expect.slice(0, 7)}`,
+      };
     if (!again.ok)
       return { ok: false, why: `it stopped answering: ${again.why}` };
     if (

package/scripts/update-run.mjs

@@ -9,11 +9,13 @@
 //   AGENTOS_UPDATE_DB     the database to back up first, into AGENTOS_UPDATE_BACKUPS
 //   AGENTOS_UPDATE_VERIFY=0  skip the health check (tests)
 //   AGENTOS_UPDATE_REDEPLOY  the script to run (tests); default scripts/redeploy
+//   AGENTOS_AUTODEPLOY_DIR  autodeploy's state dir (tests); default ~/.agent-os/autodeploy
 //   AGENTOS_UPDATE_ROOT   the checkout (tests); default this script's
 // Outcomes: done, built, build_failed (live server untouched), rolled_back,
 // broken (the rollback didn't come up either).
 import { execFileSync, spawn } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import { fileURLToPath } from "node:url";
@@ -149,6 +151,24 @@ function resetSource(from) {
   }
 }
 
+/**
+ * scripts/autodeploy's "deployed" marker must not claim a build that isn't
+ * running: after a rollback it names the build that is. Only where autodeploy
+ * runs (its state directory exists).
+ */
+function markDeployed(sha) {
+  const dir =
+    env.AGENTOS_AUTODEPLOY_DIR ||
+    path.join(os.homedir(), ".agent-os", "autodeploy");
+  if (!sha || !fs.existsSync(dir)) return;
+  try {
+    fs.writeFileSync(path.join(dir, "deployed"), `${sha}\n`);
+    say(`Recorded ${sha.slice(0, 7)} as the deployed build.`);
+  } catch (error) {
+    say(`Couldn't record the deployed build: ${error.message}`);
+  }
+}
+
 async function main() {
   const heartbeat = setInterval(() => write({}), 15_000);
   write({ pid: process.pid });
@@ -184,6 +204,14 @@ async function main() {
         expect: env.AGENTOS_UPDATE_TO || head(),
         env,
       });
+      if (ok.otherRestart) {
+        say(`Not rolling back: ${ok.why}.`);
+        return finish(
+          "failed",
+          "interrupted",
+          `The update was built, but ${ok.why}. Nothing was rolled back; check which version is running.`
+        );
+      }
       if (!ok.ok) why = ok.why;
     }
     if (!why) return finish("done", "done");
@@ -205,6 +233,7 @@ async function main() {
         say(`The rolled-back version isn't healthy either: ${ok.why}`);
       }
     }
+    if (backOk) markDeployed(from);
     return backOk
       ? finish(
           "rolled_back",

package/scripts/update-run.test.ts

@@ -78,20 +78,27 @@ describe("scripts/update-run.mjs", () => {
 
 // A stand-in for the restarted server: its build comes from a file the fake
 // redeploy writes, and its startedAt can be made to change (a crash loop).
-async function fakeServer(opts: { restarts?: boolean } = {}) {
+async function fakeServer(
+  opts: { restarts?: boolean; switchAt?: number } = {}
+) {
   let n = 0;
+  let calls = 0;
   const server = http.createServer((req, res) => {
-    const build = fs.readFileSync(path.join(dir, "build"), "utf8").trim();
+    let build = fs.readFileSync(path.join(dir, "build"), "utf8").trim();
     res.setHeader("content-type", "application/json");
-    if (req.url === "/api/updates/health")
+    if (req.url === "/api/updates/health") {
+      // Something else (a deploy job) restarts it into another build.
+      const other = opts.switchAt !== undefined && calls++ >= opts.switchAt;
+      if (other) build = "other";
       return res.end(
         JSON.stringify({
           ok: true,
           build,
-          startedAt: opts.restarts ? `s${n++}` : "s",
+          startedAt: opts.restarts ? `s${n++}` : other ? "s-other" : "s",
           migrations: { known: 3, applied: 3 },
         })
       );
+    }
     res.end("{}");
   });
   await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
@@ -170,6 +177,57 @@ describe("scripts/update-run.mjs checks the new server", () => {
     }
   });
 
+  it("a restart into a different build is left alone: no rollback, nothing marked", async () => {
+    fs.writeFileSync(path.join(dir, "next-build"), "new");
+    fs.writeFileSync(path.join(dir, "rollback-works"), "");
+    const srv = await fakeServer({ switchAt: 2 });
+    try {
+      const s = await go(REDEPLOY, "x", verifying(srv.port, "new"));
+      expect(s).toMatchObject({ phase: "failed", outcome: "interrupted" });
+      expect(s.error).toContain("something else restarted it");
+      expect(rolled()).toBeNull();
+    } finally {
+      await srv.close();
+    }
+  });
+
+  it("a rollback records the build it went back to as autodeploy's deployed marker", async () => {
+    fs.writeFileSync(path.join(dir, "next-build"), "stale");
+    fs.writeFileSync(path.join(dir, "rollback-works"), "");
+    const state = path.join(dir, "autodeploy");
+    fs.mkdirSync(state);
+    fs.writeFileSync(path.join(state, "deployed"), "f5054a0\n");
+    const srv = await fakeServer();
+    try {
+      const s = await go(REDEPLOY, "x", {
+        ...verifying(srv.port, "new"),
+        AGENTOS_AUTODEPLOY_DIR: state,
+      });
+      expect(s.outcome).toBe("rolled_back");
+      expect(fs.readFileSync(path.join(state, "deployed"), "utf8").trim()).toBe(
+        "a"
+      );
+    } finally {
+      await srv.close();
+    }
+  });
+
+  it("a rollback on a machine without autodeploy creates no marker", async () => {
+    fs.writeFileSync(path.join(dir, "next-build"), "stale");
+    fs.writeFileSync(path.join(dir, "rollback-works"), "");
+    const state = path.join(dir, "autodeploy");
+    const srv = await fakeServer();
+    try {
+      await go(REDEPLOY, "x", {
+        ...verifying(srv.port, "new"),
+        AGENTOS_AUTODEPLOY_DIR: state,
+      });
+      expect(fs.existsSync(state)).toBe(false);
+    } finally {
+      await srv.close();
+    }
+  });
+
   it("when the rollback doesn't come up either, it ends broken", async () => {
     fs.writeFileSync(path.join(dir, "next-build"), "stale");
     const srv = await fakeServer();

package/components/Away/AwayWindowForm.tsx

@@ -1,91 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { toast } from "sonner";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import {
-  useAwaySettingsQuery,
-  useUpdateAwaySettings,
-  type AwaySettings,
-} from "@/data/away";
-import {
-  MAX_WINDOW_MINUTES,
-  MIN_WINDOW_MINUTES,
-  parseWindow,
-} from "@/lib/away/window-limits";
-
-// Settings → Workspaces: how recent a session's work must be for Away mode
-// to touch it. App-wide.
-export function AwayWindowForm() {
-  const { data, isPending, isError, error } = useAwaySettingsQuery();
-  if (isPending)
-    return <div className="bg-muted/40 h-24 animate-pulse rounded-lg" />;
-  if (isError)
-    return <p className="text-destructive text-sm">{error.message}</p>;
-  return <Form key={data.windowMinutes} saved={data} />;
-}
-
-function Form({ saved }: { saved: AwaySettings }) {
-  const update = useUpdateAwaySettings();
-  const [text, setText] = useState(String(saved.windowMinutes));
-  const minutes = parseWindow(text);
-  const error =
-    minutes === null
-      ? `A whole number from ${MIN_WINDOW_MINUTES} to ${MAX_WINDOW_MINUTES}`
-      : null;
-  return (
-    <form
-      onSubmit={(e) => {
-        e.preventDefault();
-        if (minutes === null) return;
-        update.mutate(
-          { windowMinutes: minutes },
-          {
-            onSuccess: () => toast.success("Away mode settings saved"),
-            onError: (err) => toast.error(err.message),
-          }
-        );
-      }}
-      className="bg-muted/40 space-y-3 rounded-lg px-3 py-3"
-    >
-      <h3 className="text-sm font-medium">Away mode</h3>
-      <p className="text-muted-foreground text-sm">
-        Away mode works through orchestrators that were busy in this window, and
-        only lists sessions with a real turn inside it. Older ones are left
-        alone: a message wakes an agent and re-reads its whole conversation.
-      </p>
-      <label className="flex items-center justify-between gap-3 text-sm">
-        <span className="text-muted-foreground">Recent means the last</span>
-        <span className="flex items-center gap-2">
-          <Input
-            type="number"
-            inputMode="numeric"
-            min={MIN_WINDOW_MINUTES}
-            max={MAX_WINDOW_MINUTES}
-            step={1}
-            value={text}
-            onChange={(e) => setText(e.target.value)}
-            aria-label="Away window, minutes"
-            aria-invalid={!!error}
-            className="h-11 w-24 text-base sm:h-9 md:text-sm"
-          />
-          <span className="text-muted-foreground">min</span>
-        </span>
-      </label>
-      {error && <p className="text-destructive text-xs">{error}</p>}
-      <div className="flex justify-end">
-        <Button
-          type="submit"
-          size="sm"
-          className="h-11 sm:h-8"
-          disabled={
-            !!error || minutes === saved.windowMinutes || update.isPending
-          }
-        >
-          Save
-        </Button>
-      </div>
-    </form>
-  );
-}

package/components/Workspaces/FreshStartForm.tsx

@@ -1,177 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { toast } from "sonner";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { Switch } from "@/components/ui/switch";
-import type { RefreshSettings } from "@/lib/chat/refresh";
-import { useFreshStartQuery, useUpdateFreshStart } from "@/data/fresh-start";
-import { parseFreshStart } from "./fresh-start";
-
-// When a chat's agent starts a fresh conversation instead of carrying a
-// long one: app-wide, one threshold for orchestrators and one for tasks.
-export function FreshStartForm() {
-  const { data, isPending, isError, error } = useFreshStartQuery();
-  if (isPending)
-    return <div className="bg-muted/40 h-24 animate-pulse rounded-lg" />;
-  if (isError)
-    return <p className="text-destructive text-sm">{error.message}</p>;
-  return (
-    <Form
-      key={`${data.orchestratorTokens}:${data.taskTokens}:${data.compactTokens}:${data.autoCompactTokens}:${data.interactiveAutoCompactTokens}`}
-      saved={data}
-    />
-  );
-}
-
-function Form({ saved }: { saved: RefreshSettings }) {
-  const update = useUpdateFreshStart();
-  const orchestrator = useThreshold(saved.orchestratorTokens, 200);
-  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 ??
-    interactive.error;
-  const dirty =
-    !error &&
-    (orchestrator.tokens !== saved.orchestratorTokens ||
-      task.tokens !== saved.taskTokens ||
-      compact.tokens !== saved.compactTokens ||
-      midTurn.tokens !== saved.autoCompactTokens ||
-      interactive.tokens !== saved.interactiveAutoCompactTokens);
-
-  return (
-    <form
-      onSubmit={(e) => {
-        e.preventDefault();
-        if (error) return;
-        update.mutate(
-          {
-            orchestratorTokens: orchestrator.tokens,
-            taskTokens: task.tokens,
-            compactTokens: compact.tokens,
-            autoCompactTokens: midTurn.tokens,
-            interactiveAutoCompactTokens: interactive.tokens,
-          },
-          {
-            onSuccess: () => toast.success("Context settings saved"),
-            onError: (err) => toast.error(err.message),
-          }
-        );
-      }}
-      className="bg-muted/40 space-y-3 rounded-lg px-3 py-3"
-    >
-      <h3 className="text-sm font-medium">Fresh starts</h3>
-      <p className="text-muted-foreground text-sm">
-        When a conversation&apos;s context passes the threshold, its agent
-        starts a new one at the next turn boundary, with its brief. An
-        orchestrator also gets its rules and the workspace&apos;s current state,
-        so nothing is lost. A task keeps only its brief and its branch.
-      </p>
-      <ThresholdRow label="Orchestrators" field={orchestrator} />
-      <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 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.
-        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, tasks"
-        field={midTurn}
-        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"
-        field={compact}
-        switchLabel="Compact chats and tasks between turns"
-      />
-      {error && <p className="text-destructive text-xs">{error}</p>}
-      <div className="flex justify-end">
-        <Button
-          type="submit"
-          size="sm"
-          className="h-11 sm:h-8"
-          disabled={!!error || !dirty || update.isPending}
-        >
-          Save
-        </Button>
-      </div>
-    </form>
-  );
-}
-
-function useThreshold(tokens: number, fallbackK: number) {
-  const [on, setOn] = useState(tokens > 0);
-  const [text, setText] = useState(
-    String(tokens > 0 ? tokens / 1000 : fallbackK)
-  );
-  const parsed = parseFreshStart(on, text);
-  return {
-    on,
-    setOn,
-    text,
-    setText,
-    tokens: "tokens" in parsed ? parsed.tokens : tokens,
-    error: "error" in parsed ? parsed.error : null,
-  };
-}
-
-function ThresholdRow({
-  label,
-  field,
-  switchLabel,
-}: {
-  label: string;
-  field: ReturnType<typeof useThreshold>;
-  switchLabel?: string;
-}) {
-  return (
-    <div className="space-y-2">
-      <label className="flex min-h-11 items-center justify-between gap-3 text-sm md:min-h-9">
-        {label}
-        <Switch
-          checked={field.on}
-          onCheckedChange={field.setOn}
-          aria-label={switchLabel ?? `Fresh starts for ${label.toLowerCase()}`}
-        />
-      </label>
-      {field.on && (
-        <label className="flex items-center justify-between gap-3 text-sm">
-          <span className="text-muted-foreground">At</span>
-          <span className="flex items-center gap-2">
-            <Input
-              type="number"
-              inputMode="numeric"
-              min={50}
-              step={10}
-              value={field.text}
-              onChange={(e) => field.setText(e.target.value)}
-              aria-label={`${label} threshold, thousands of tokens`}
-              aria-invalid={!!field.error}
-              className="h-11 w-24 text-base sm:h-9 md:text-sm"
-            />
-            <span className="text-muted-foreground">k tokens</span>
-          </span>
-        </label>
-      )}
-    </div>
-  );
-}