@saadnvd1/agent-os 0.3.836 → 0.3.839

package/data/fresh-start/index.ts

@@ -24,7 +24,7 @@ export function useUpdateFreshStart() {
     mutationFn: async (settings: Partial<RefreshSettings>) =>
       json<RefreshSettings>(
         await fetch("/api/fresh-start", {
-          method: "PUT",
+          method: "PATCH",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify(settings),
         })

package/data/workspaces/index.ts

@@ -87,6 +87,9 @@ export function useUpdateWorkspace() {
       ...updates
     }) => {
       await queryClient.cancelQueries({ queryKey: workspaceKeys.list() });
+      const previous = queryClient.getQueryData<Workspace[]>(
+        workspaceKeys.list()
+      );
       queryClient.setQueryData<Workspace[]>(workspaceKeys.list(), (prev) =>
         prev?.map((w) =>
           w.id === id
@@ -109,6 +112,12 @@ export function useUpdateWorkspace() {
             : w
         )
       );
+      return { previous };
+    },
+    // A rejected change rolls back to what the server holds.
+    onError: (_err, _vars, context) => {
+      if (context?.previous)
+        queryClient.setQueryData(workspaceKeys.list(), context.previous);
     },
     onSettled: () =>
       queryClient.invalidateQueries({ queryKey: workspaceKeys.all }),

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/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/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/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/package.json

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

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>
-  );
-}