feat: model lists and prices that follow each AI tool, a Settings tab per tool, live lane status (#40)

Pricing: the LiteLLM sync now adds every current Claude / GPT (>= 5) /
Gemini (>= 3) chat model before it is used and keeps its own rows
(model_pricing.source = 'sync', the Auto badge) at the published rate. A
user's row (any PUT) and a deleted pattern (model_pricing_dismissed) are
never touched; a deleted built-in row is not re-seeded at the next start; a
reset re-applies the list at once; retired Claude models are priced only
once used.

Models: GET /api/ai-tools/:id/models reads each tool's own list (Codex's
models_cache.json, Claude's aliases named after the newest version plus
priced versions, a catalog tool's vendor rows plus the models its sessions
used). A catalog `model: {flag, vendor?}` field passes `<flag> <id>`
(validated: never a flag or shell text); a per-tool default model starts
each run, and a resume keeps the session's own model.

Settings: every installed, enabled catalog tool without its own tab gets
one (AiToolConfig.tsx): path, homepage, Update, sessions/cost/lanes,
default model, vendor pricing, and the config files its release catalog
lists, edited over the opened sha, syntax-checked, backed up, written
atomically; credential-looking names refused. Antigravity keeps its hooks
card there.

Lanes: a just-started run no longer reads "dead" (age counts the run's
start while the old session is still bound); a second dashboard on the
same database re-broadcasts the lanes the other changed (PRAGMA
data_version, every 2 s); a lane start with a bad model answers 400.

DB: every migration runs under a cross-process lock (<db>-migrate.lock), so
two dashboards started at once on a fresh database both come up.

client/src/components/lanes/__tests__/AddLaneModal.test.tsx

@@ -53,6 +53,10 @@ const tool = (id: string, label: string, over: Partial<AiTool> = {}): AiTool =>
   routerCapable: false,
   install: null,
   update: null,
+  modelFlag: false,
+  defaultModel: null,
+  modelVendor: null,
+  configFiles: 0,
   ...over,
 });
 const TOOLS: AiToolsView = {

client/src/components/run/LaneConsolePane.tsx

@@ -152,6 +152,12 @@ export function LaneConsolePane({
   );
   const aiTools = useAiTools();
   const toolLabel = aiTools.label(laneTool);
+  // A new run starts on the tool's default model (AI Tools settings), and a
+  // lane switch to another tool drops the previous tool's pick.
+  const defaultModel = aiTools.byId(laneTool)?.defaultModel ?? "";
+  useEffect(() => {
+    setModel(defaultModel);
+  }, [laneTool, defaultModel]);
 
   useEffect(() => {
     onHasActiveRunChange?.(handle !== null);

client/src/components/run/RunSetup.tsx

@@ -43,7 +43,7 @@ import {
   RotateCcw,
   Lock,
 } from "lucide-react";
-import { api, RUN_MODEL_CHOICES, RUN_MODEL_CHOICES_CODEX, RUN_EFFORT_CHOICES } from "../../lib/api";
+import { api, RUN_MODEL_CHOICES, RUN_EFFORT_CHOICES, type ModelChoice } from "../../lib/api";
 import type {
   CwdSuggestion,
   DashboardRunHistoryItem,
@@ -409,6 +409,8 @@ export function RunSetup(props: RunSetupProps) {
   // Per run, never remembered: the form starts unticked every time it mounts.
   const [bypass, setBypass] = useState(false);
   const canBypass = props.tool !== "claude" && !!entry?.bypass;
+  // Claude and Codex always take a model; a catalog tool only when its file names the flag.
+  const hasModel = !catalogTool || !!entry?.modelFlag;
   // Keep "resume picked" in sync with the parent. Parent set a resume session
   // (e.g. user clicked Resume in the runs modal) - flip the radio so the picker
   // is shown and the selection is visible.
@@ -441,8 +443,8 @@ export function RunSetup(props: RunSetupProps) {
               </div>
             )}
           </Field>
-          {/* A catalog tool takes no model, permission or effort flag. */}
-          {!catalogTool && (
+          {/* A catalog tool takes no permission or effort flag, and a model only when it declares one. */}
+          {hasModel && (
             <Field label={t("fields.model")}>
               <ModelPicker value={props.model} onChange={props.onModelChange} tool={props.tool} />
             </Field>
@@ -532,7 +534,8 @@ export function RunSetup(props: RunSetupProps) {
                   // Pass the picked session explicitly: the parent's state
                   // update has not landed yet on this tick, so reading
                   // props.resumeSession here would resume nothing.
-                  if (s && !props.busy) handleStart(props, s, bypass);
+                  if (s && !props.busy)
+                    handleStart(props, s, bypass, hasModel, entry?.defaultModel);
                 }}
                 // Fall back to the typed cwd when no lane is selected — otherwise
                 // an unfiltered picker lists every session from every repo.
@@ -559,7 +562,9 @@ export function RunSetup(props: RunSetupProps) {
         <PromptEditor
           value={props.prompt}
           onChange={props.onPromptChange}
-          onSubmit={() => handleStart(props, undefined, canBypass && bypass)}
+          onSubmit={() =>
+            handleStart(props, undefined, canBypass && bypass, hasModel, entry?.defaultModel)
+          }
           placeholder={t("fields.promptPlaceholderTerminal", { tool: aiTools.label(props.tool) })}
           rows={5}
           slash={props.tool === "claude"}
@@ -615,7 +620,9 @@ export function RunSetup(props: RunSetupProps) {
           ) : null}
         </div>
         <button
-          onClick={() => handleStart(props, undefined, canBypass && bypass)}
+          onClick={() =>
+            handleStart(props, undefined, canBypass && bypass, hasModel, entry?.defaultModel)
+          }
           disabled={
             !props.binaryFound ||
             // A resume needs no prompt — the session it continues is the input.
@@ -644,7 +651,13 @@ export function RunSetup(props: RunSetupProps) {
 
 /** `session` overrides `props.resumeSession` for the auto-start fired straight
  *  out of the picker, before the parent's state has caught up. */
-function handleStart(props: RunSetupProps, session?: Session, bypass?: boolean) {
+function handleStart(
+  props: RunSetupProps,
+  session?: Session,
+  bypass?: boolean,
+  hasModel?: boolean,
+  defaultModel?: string | null
+) {
   const resume = session ?? props.resumeSession;
   const codex = props.tool === "codex";
   // Any catalog tool: none of Claude's or Codex's own flags apply.
@@ -654,7 +667,12 @@ function handleStart(props: RunSetupProps, session?: Session, bypass?: boolean)
     // A resume is pinned to its own session's folder — that's what the locked
     // cwd field shows, so it's what gets sent.
     cwd: resume?.cwd || props.cwd || undefined,
-    model: other ? undefined : props.model || undefined,
+    // A resume keeps the session's own model: the tool's default the form
+    // starts on is not a pick, so only a model the user changed is sent.
+    model:
+      !(other ? hasModel : true) || (resume && props.model === (defaultModel ?? ""))
+        ? undefined
+        : props.model || undefined,
     permissionMode: codex || other ? undefined : props.permissionMode || undefined,
     sandbox: codex ? props.sandbox : undefined,
     approval: codex ? props.approval : undefined,
@@ -1029,7 +1047,7 @@ function SessionPicker({
 // the "inherit from settings" choice, so use a non-empty marker.
 const MODEL_CUSTOM = "__custom__";
 
-function ModelPicker({
+export function ModelPicker({
   value,
   onChange,
   tool,
@@ -1039,11 +1057,31 @@ function ModelPicker({
   tool: LaneTool;
 }) {
   const { t } = useTranslation("run");
-  const choices = tool === "codex" ? RUN_MODEL_CHOICES_CODEX : RUN_MODEL_CHOICES;
-  // "Custom" is selected when the value isn't one of our curated IDs.
+  // The tool's own list (Codex's models cache, Claude's aliases named after
+  // the newest version, a catalog tool's vendor rows); Claude's static
+  // aliases only when the server cannot answer.
+  const [fetched, setFetched] = useState<ModelChoice[] | null>(null);
+  useEffect(() => {
+    let live = true;
+    setFetched(null);
+    Promise.resolve()
+      .then(() => api.aiTools.models(tool))
+      .then((r) => live && setFetched(r.models))
+      .catch(() => live && setFetched([]));
+    return () => {
+      live = false;
+    };
+  }, [tool]);
+  const choices = useMemo<ModelChoice[]>(() => {
+    const inherit = { id: "", label: "" };
+    if (fetched?.length) return [inherit, ...fetched];
+    return tool === "claude" ? RUN_MODEL_CHOICES : [inherit];
+  }, [fetched, tool]);
+  // "Custom" is selected when the value isn't one of the listed IDs — judged
+  // only once the list has arrived, so a listed default never flashes as custom.
   const knownIds = useMemo(() => choices.map((c) => c.id), [choices]);
-  const isCustom = value !== "" && !knownIds.includes(value);
-  const [showCustom, setShowCustom] = useState(isCustom);
+  const isCustom = fetched !== null && value !== "" && !knownIds.includes(value);
+  const [showCustom, setShowCustom] = useState(false);
 
   // Reuse the shared Select so the Model dropdown renders identically to the
   // Permission Mode and Effort dropdowns (Tailwind + lucide popover) instead of

client/src/components/run/__tests__/LaneConsolePane.test.tsx

@@ -10,6 +10,7 @@ import { MemoryRouter } from "react-router-dom";
 import { LaneConsolePane } from "../LaneConsolePane";
 import { api } from "../../../lib/api";
 import type { Lane } from "../../../lib/types";
+import { __resetAiTools } from "../../../hooks/useAiTools";
 
 vi.mock("../TerminalView", () => ({
   // The exit button stands in for the server's `exit` frame (a double Ctrl+C
@@ -28,6 +29,10 @@ vi.mock("../../../lib/api", () => ({
       action: vi.fn(),
       list: vi.fn(),
     },
+    aiTools: {
+      list: vi.fn().mockResolvedValue({ default: "claude", tools: [] }),
+      models: vi.fn().mockResolvedValue({ flag: true, models: [], defaultModel: null }),
+    },
     run: {
       list: vi.fn().mockResolvedValue({ items: [] }),
       history: vi.fn().mockResolvedValue({ items: [] }),
@@ -36,7 +41,6 @@ vi.mock("../../../lib/api", () => ({
     },
   },
   RUN_MODEL_CHOICES: [],
-  RUN_MODEL_CHOICES_CODEX: [],
   RUN_EFFORT_CHOICES: [],
 }));
 
@@ -136,6 +140,31 @@ describe("LaneConsolePane", () => {
     );
   });
 
+  it("starts a run on the tool's default model from AI Tools settings", async () => {
+    __resetAiTools();
+    (api.aiTools.list as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      default: "claude",
+      tools: [{ id: "claude", label: "Claude Code", defaultModel: "sonnet", modelFlag: true }],
+    });
+    (api.lanes.action as ReturnType<typeof vi.fn>).mockResolvedValue({ lane: LANE });
+    render(<LaneConsolePane {...baseProps()} />);
+    fireEvent.change(screen.getByPlaceholderText(/type to search/i), {
+      target: { value: "/workspace/a" },
+    });
+    fireEvent.change(screen.getByPlaceholderText(/ask claude/i), { target: { value: "go" } });
+    await waitFor(() => expect(api.aiTools.list).toHaveBeenCalled());
+    await new Promise((r) => setTimeout(r, 0));
+    fireEvent.click(screen.getByRole("button", { name: /^run$/i }));
+    await waitFor(() =>
+      expect(api.lanes.action).toHaveBeenCalledWith(
+        1,
+        "start",
+        expect.objectContaining({ model: "sonnet" })
+      )
+    );
+    __resetAiTools();
+  });
+
   it("returns to the setup form when the pane exits, without a New run click", async () => {
     (api.lanes.action as ReturnType<typeof vi.fn>).mockResolvedValue({
       lane: { ...LANE, run_id: "run-1" },

client/src/components/run/__tests__/RunSetup.test.tsx

@@ -29,12 +29,37 @@ vi.mock("../../../lib/api", async (importOriginal) => {
         list: r({
           default: "claude",
           tools: [
-            { id: "claude", label: "Claude Code", resume: false, bypass: false },
+            {
+              id: "claude",
+              label: "Claude Code",
+              resume: false,
+              bypass: false,
+              modelFlag: true,
+              defaultModel: "sonnet",
+            },
             { id: "codex", label: "Codex", resume: false, bypass: true },
-            { id: "antigravity", label: "Antigravity", resume: true, bypass: true },
+            {
+              id: "antigravity",
+              label: "Antigravity",
+              resume: true,
+              bypass: true,
+              modelFlag: true,
+            },
             { id: "gemini", label: "Gemini", resume: false, bypass: false },
           ].map((x) => ({ ...x, installed: true, enabled: true, command: x.id })),
         }),
+        // Each tool's own model list, as GET /api/ai-tools/:id/models answers it.
+        models: vi.fn(async (id: string) => {
+          const lists: Record<string, { id: string; label: string }[]> = {
+            claude: [
+              { id: "sonnet", label: "Sonnet (latest · 5.5)" },
+              { id: "claude-sonnet-5-5", label: "Claude Sonnet 5.5" },
+            ],
+            codex: [{ id: "gpt-6-sol", label: "GPT-6-Sol" }],
+            antigravity: [{ id: "gemini-3.1-pro", label: "gemini-3.1-pro" }],
+          };
+          return { flag: id in lists, models: lists[id] ?? [], defaultModel: null };
+        }),
       },
       run: { files: r({ items: [] }) },
       sessions: { list: r({ sessions: [], total: 0, limit: 100, offset: 0 }) },
@@ -145,11 +170,12 @@ describe("RunSetup — selections report through callbacks", () => {
     onlyCalled(spies, "onCwdChange");
   });
 
-  it("reports the model from the picker, including a custom id", () => {
+  it("reports the model from the picker, including a custom id", async () => {
     const { spies } = renderSetup();
-    // The picker offers the CLI's "latest" aliases, not pinned ids — that is
-    // what keeps the list from going stale on every model release.
-    pickFromSelect(i18n.t("run:fields.modelInheritLabel"), "Sonnet (latest)");
+    // The list is the tool's own, fetched from the server — aliases named
+    // after the newest version, then pinned versions — never a hardcoded copy.
+    fireEvent.click(screen.getByText(i18n.t("run:fields.modelInheritLabel")));
+    fireEvent.click(await screen.findByText("Sonnet (latest · 5.5)"));
     expect(spies.onModelChange).toHaveBeenCalledWith("sonnet");
     // "Custom…" is a sentinel, not a model id — it must not be reported as one;
     // the free-text box it reveals is what reports.
@@ -374,6 +400,27 @@ describe("RunSetup — resume picker scopes sessions to the selected lane", () =
   });
 });
 
+describe("RunSetup — resume keeps the session's model", () => {
+  const session = { id: "sess-1", cwd: "/Users/tester" } as never;
+
+  it("sends no model when it is still the tool's default", async () => {
+    const { spies } = renderSetup({ resumeSession: session, model: "sonnet", prompt: "" });
+    await screen.findByText(i18n.t("run:fields.model"));
+    await new Promise((r) => setTimeout(r, 0));
+    fireEvent.click(screen.getByText(i18n.t("run:actions.start")));
+    expect(spies.onStart).toHaveBeenCalledWith(
+      expect.objectContaining({ resumeSessionId: "sess-1", model: undefined })
+    );
+  });
+
+  it("sends a model the user picked", async () => {
+    const { spies } = renderSetup({ resumeSession: session, model: "opus", prompt: "" });
+    await new Promise((r) => setTimeout(r, 0));
+    fireEvent.click(screen.getByText(i18n.t("run:actions.start")));
+    expect(spies.onStart).toHaveBeenCalledWith(expect.objectContaining({ model: "opus" }));
+  });
+});
+
 describe("RunSetup — per-tool fields", () => {
   it("shows sandbox and approval instead of permission mode for a codex lane", () => {
     renderSetup({ tool: "codex" });
@@ -457,20 +504,38 @@ describe("RunSetup — / and @ suggestions in the prompt box", () => {
 });
 
 describe("RunSetup — antigravity lanes", () => {
-  it("names the lane's CLI in the prompt box and drops the flags `agy` lacks", () => {
-    const { spies } = renderSetup({ tool: "antigravity", model: "opus", effort: "high" });
+  it("names the lane's CLI, offers its model flag and drops the flags `agy` lacks", async () => {
+    const { spies } = renderSetup({ tool: "antigravity", model: "gemini-3.1-pro", effort: "high" });
     expect(screen.getByPlaceholderText("Ask Antigravity anything…")).toBeTruthy();
-    expect(screen.queryByText(i18n.t("run:fields.model"))).toBeNull();
+    expect(await screen.findByText(i18n.t("run:fields.model"))).toBeTruthy();
     expect(screen.queryByText(i18n.t("run:fields.effort"))).toBeNull();
 
     fireEvent.click(screen.getByText(i18n.t("run:actions.start")));
     expect(spies.onStart).toHaveBeenCalledWith(
-      expect.objectContaining({ model: undefined, effort: undefined, permissionMode: undefined })
+      expect.objectContaining({
+        model: "gemini-3.1-pro",
+        effort: undefined,
+        permissionMode: undefined,
+      })
     );
   });
+
+  it("sends no model for a catalog tool whose CLI has no model flag", async () => {
+    const { spies } = renderSetup({ tool: "gemini", model: "stale", prompt: "go" });
+    await screen.findByPlaceholderText("Ask Gemini anything…");
+    expect(screen.queryByText(i18n.t("run:fields.model"))).toBeNull();
+    fireEvent.click(screen.getByText(i18n.t("run:actions.start")));
+    expect(spies.onStart).toHaveBeenCalledWith(expect.objectContaining({ model: undefined }));
+  });
 });
 
 describe("RunSetup — codex lanes", () => {
+  it("offers the models Codex itself lists", async () => {
+    renderSetup({ tool: "codex" });
+    fireEvent.click(screen.getByText(i18n.t("run:fields.modelInheritLabel")));
+    expect(await screen.findByText("GPT-6-Sol")).toBeTruthy();
+  });
+
   it("starts a fresh codex run instead of resuming the last one", () => {
     const { spies } = renderSetup({ tool: "codex" });
     fireEvent.click(screen.getByText(i18n.t("run:actions.start")));

client/src/components/settings/PricingSettings.tsx

@@ -76,9 +76,8 @@ function formatTimestamp(iso: string): string {
 /**
  * Info popover for the Model Pricing section. Hover or focus the icon to see a
  * three-section explanation: how prices are applied, how pattern matching
- * works, and — for Claude — a reminder that prices must be edited manually
- * when Anthropic publishes new rates; another vendor's rows come from
- * LiteLLM's price list, so its tab says that instead. All copy is i18n-driven
+ * works, and where the rates come from (LiteLLM's price list, kept up to date
+ * daily for the rows marked Auto). All copy is i18n-driven
  * (settings.pricing.tooltip.*).
  *
  * The popover is fixed-positioned and clamped to the viewport so it never
@@ -165,11 +164,9 @@ function PricingInfoTooltip({ vendor }: { vendor: PricingVendor }) {
           </p>
 
           <p className="font-semibold text-status-warning uppercase tracking-wider text-[9px] mb-1">
-            {t(claude ? "pricing.tooltip.manualUpdates" : "pricing.tooltip.synced")}
-          </p>
-          <p className="text-fg-secondary leading-snug mb-2.5">
-            {t(claude ? "pricing.tooltip.manualUpdatesBody" : "pricing.tooltip.syncedBody")}
+            {t("pricing.tooltip.synced")}
           </p>
+          <p className="text-fg-secondary leading-snug mb-2.5">{t("pricing.tooltip.syncedBody")}</p>
 
           <p className="font-semibold text-status-warning uppercase tracking-wider text-[9px] mb-1">
             {t("pricing.tooltip.apiPricing")}
@@ -673,6 +670,14 @@ export function PricingSettings({ vendor, allowReset = false, id = "pricing" }:
                   </td>
                   <td className="px-4 py-3 text-sm text-fg-secondary">
                     {rule.display_name}
+                    {rule.source === "sync" && (
+                      <span
+                        title={t("pricing.autoBadgeTitle")}
+                        className="ml-2 rounded bg-accent/10 px-1.5 py-0.5 text-[10px] font-medium text-accent"
+                      >
+                        {t("pricing.autoBadge")}
+                      </span>
+                    )}
                     {rule.intro_until && (
                       <div className="text-[11px] font-normal text-violet-700/80 dark:text-violet-400/80 mt-0.5">
                         {t("pricing.introNote", {

client/src/components/settings/__tests__/AiToolsSettings.test.tsx

@@ -54,6 +54,10 @@ const tool = (id: string, label: string, over: Partial<AiTool> = {}): AiTool =>
   routerCapable: false,
   install: null,
   update: null,
+  modelFlag: false,
+  defaultModel: null,
+  modelVendor: null,
+  configFiles: 0,
   ...over,
 });
 const VIEW: AiToolsView = {
@@ -257,6 +261,28 @@ describe("SettingsHub — AI tool tabs", () => {
     expect(screen.queryByRole("tab", { name: /^Codex/ })).toBeNull();
   });
 
+  it("gives every installed, enabled catalog tool its own tab, and none to the rest", async () => {
+    vi.mocked(api.aiTools.list).mockResolvedValue({
+      default: "claude",
+      tools: [
+        tool("claude", "Claude Code", { launcher: "claude" }),
+        tool("gemini", "Gemini"),
+        tool("qwen-code", "Qwen Code", { enabled: false }),
+        tool("aider", "Aider", { installed: false }),
+      ],
+    });
+    vi.doMock("../../../pages/Settings", () => ({ Settings: () => null }));
+    const { SettingsHub } = await import("../../../pages/SettingsHub");
+    render(
+      <MemoryRouter>
+        <SettingsHub />
+      </MemoryRouter>
+    );
+    expect(await screen.findByRole("tab", { name: /Gemini/ })).toBeInTheDocument();
+    expect(screen.queryByRole("tab", { name: /Qwen Code/ })).toBeNull();
+    expect(screen.queryByRole("tab", { name: /Aider/ })).toBeNull();
+  });
+
   it("opens AI Tools as a modal from the tab bar, and closes it on Escape", async () => {
     vi.doMock("../../../pages/Settings", () => ({ Settings: () => null }));
     const { SettingsHub } = await import("../../../pages/SettingsHub");

client/src/components/settings/__tests__/PricingSettings.test.tsx

@@ -61,6 +61,18 @@ describe("PricingSettings", () => {
     expect(screen.getByText("claude-opus-5-5%")).toBeInTheDocument();
   });
 
+  it("marks a row the automatic sync keeps up to date", async () => {
+    vi.mocked(api.pricing.list).mockResolvedValue({
+      pricing: [
+        { ...rule("gpt-6-sol%", "GPT-6 Sol"), source: "sync" },
+        { ...rule("gpt-5.6-sol%", "GPT-5.6 Sol"), source: "user" },
+      ],
+    });
+    render(<PricingSettings vendor="openai" />);
+    await screen.findByText("gpt-6-sol%");
+    expect(screen.getAllByText("Auto")).toHaveLength(1);
+  });
+
   it("says where OpenAI prices come from when there are none", async () => {
     vi.mocked(api.pricing.list).mockResolvedValue({ pricing: [ROWS[0]!] });
     render(<PricingSettings vendor="openai" />);