@saadnvd1/agent-os 0.3.555 → 0.3.557

package/README.md

@@ -27,6 +27,7 @@ and check on all of it from your phone.
 - **Workspaces.** Group projects, finish work with Done, and get a log of every merged task. [More](docs/reference/workspaces.md)
 - **LumifyHub (optional).** Boards, cards and docs for a workspace, if you want them. [More](docs/lumifyhub.md)
 - **No approvals mode.** One switch in Settings that approves every ask, lets brakes and plan-only tasks through, and starts every agent with its permission prompts off; each approval it makes is logged. Off by default. [More](docs/reference/orchestrator.md#no-approvals-mode)
+- **Experiments.** Settings → Experiments lists features still being tried, each off until you turn it on, with what it has cost and how often its suggestions were taken. [More](docs/decisions/2026-10-13-experiments.md)
 - **Also:** a ⌘K palette, code search, a file picker, a git panel, dev servers, up to four panes, and dictation.
 
 ## Documentation

package/app/api/experiments/[id]/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from "next/server";
+import { experimentsLocked, setExperiment } from "@/lib/experiments";
+import { isExperimentId } from "@/lib/experiments/registry";
+import { usageDetail } from "@/lib/experiments/meter";
+import { experimentView } from "@/lib/experiments/view";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+// GET /api/experiments/:id - the experiment with its per-day usage
+export async function GET(_req: NextRequest, { params }: Ctx) {
+  const { id } = await params;
+  if (!isExperimentId(id))
+    return NextResponse.json({ error: "Unknown experiment" }, { status: 404 });
+  return NextResponse.json({
+    ...experimentView(id),
+    locked: experimentsLocked(),
+    detail: usageDetail(id),
+  });
+}
+
+// PUT /api/experiments/:id {on} - anyone using the app may switch one
+export async function PUT(request: NextRequest, { params }: Ctx) {
+  const { id } = await params;
+  if (!isExperimentId(id))
+    return NextResponse.json({ error: "Unknown experiment" }, { status: 404 });
+  const body = (await request.json().catch(() => ({}))) as { on?: unknown };
+  if (typeof body.on !== "boolean")
+    return NextResponse.json(
+      { error: "on must be true or false" },
+      { status: 400 }
+    );
+  if (experimentsLocked())
+    return NextResponse.json(
+      { error: "Experiments are switched off for this server" },
+      { status: 409 }
+    );
+  setExperiment(id, body.on);
+  return NextResponse.json(experimentView(id));
+}

package/app/api/experiments/route.test.ts

@@ -0,0 +1,51 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it } from "vitest";
+import { db } from "@/lib/db";
+import { experimentOn } from "@/lib/experiments";
+import { GET } from "./route";
+import * as one from "./[id]/route";
+
+const ctx = (id: string) => ({ params: Promise.resolve({ id }) });
+const put = (id: string, body: unknown) =>
+  one.PUT(
+    new NextRequest(`http://localhost/api/experiments/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(body),
+    }),
+    ctx(id)
+  );
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM settings WHERE key LIKE 'experiments.%'`).run();
+});
+
+describe("/api/experiments", () => {
+  it("lists every experiment, off, with zero usage", async () => {
+    const body = await (await GET()).json();
+    const e = body.experiments.find(
+      (x: { id: string }) => x.id === "learning-cards"
+    );
+    expect(e).toMatchObject({ on: false, status: "experimental" });
+    expect(e.usage.today.calls).toBe(0);
+  });
+
+  it("switches one on and off", async () => {
+    expect((await put("learning-cards", { on: true })).status).toBe(200);
+    expect(experimentOn("learning-cards")).toBe(true);
+    await put("learning-cards", { on: false });
+    expect(experimentOn("learning-cards")).toBe(false);
+  });
+
+  it("refuses an unknown id and a bad body", async () => {
+    expect((await put("nope", { on: true })).status).toBe(404);
+    expect((await put("learning-cards", { on: "yes" })).status).toBe(400);
+  });
+
+  it("gives the detail view", async () => {
+    const res = await one.GET(
+      new NextRequest("http://localhost/api/experiments/learning-cards"),
+      ctx("learning-cards")
+    );
+    expect((await res.json()).detail.days).toHaveLength(30);
+  });
+});

package/app/api/experiments/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from "next/server";
+import { experimentsView } from "@/lib/experiments/view";
+
+// GET /api/experiments - every experiment, whether it's on, and what it used
+export function GET() {
+  return NextResponse.json(experimentsView());
+}

package/app/api/sessions/[id]/done/route.test.ts

@@ -0,0 +1,70 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const doneSession = vi.hoisted(() => vi.fn());
+const deadline = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/done", () => ({
+  doneSession,
+  getDoneTarget: (id: string) => {
+    if (id === "gone") throw new Error("Session not found");
+    return { id, name: "Fix pair page menu label" };
+  },
+}));
+vi.mock("@/lib/done/deadline", () => ({
+  withinDeadline: (...a: unknown[]) => {
+    deadline(...a);
+    return a[0];
+  },
+}));
+
+const { POST } = await import("./route");
+const post = (id: string) =>
+  POST(new Request("http://x", { method: "POST" }), {
+    params: Promise.resolve({ id }),
+  });
+
+const unhandled: unknown[] = [];
+process.on("unhandledRejection", (e) => unhandled.push(e));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  unhandled.length = 0;
+});
+
+describe("POST /api/sessions/:id/done", () => {
+  it("answers 404 for an unknown id, without starting anything or leaving a rejection", async () => {
+    const res = await post("gone");
+    expect(res.status).toBe(404);
+    expect(doneSession).not.toHaveBeenCalled();
+    await new Promise((r) => setTimeout(r, 10));
+    expect(unhandled).toEqual([]);
+  });
+
+  it("runs a quick change's done through the deadline wrapper", async () => {
+    doneSession.mockResolvedValue({ text: "Merged." });
+    const res = await post("q1");
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ outcome: { text: "Merged." } });
+    expect(deadline).toHaveBeenCalledWith(
+      expect.any(Promise),
+      "Fix pair page menu label"
+    );
+  });
+
+  it("returns the refusal, and a second done while one runs is refused", async () => {
+    let finish!: (v: unknown) => void;
+    doneSession.mockReturnValueOnce(new Promise((r) => (finish = r)));
+    const first = post("q2");
+    await new Promise((r) => setTimeout(r, 0));
+    const second = await post("q2");
+    expect(second.status).toBe(409);
+    expect((await second.json()).error).toMatch(/already being finished/);
+    expect(doneSession).toHaveBeenCalledTimes(1);
+    finish({ text: "ok" });
+    expect((await first).status).toBe(200);
+
+    doneSession.mockRejectedValueOnce(new Error("Not done. ci failed"));
+    const refused = await post("q2");
+    expect(refused.status).toBe(409);
+    expect((await refused.json()).error).toMatch(/ci failed/);
+  });
+});

package/app/api/sessions/[id]/done/route.ts

@@ -1,19 +1,45 @@
 import { NextResponse } from "next/server";
-import { doneSession } from "@/lib/done";
+import { doneSession, getDoneTarget } from "@/lib/done";
+import { withinDeadline } from "@/lib/done/deadline";
+
+// Sessions with a done running. Released when the work ends, not when the
+// request's deadline does, so a retry can't start a parallel run beside one
+// that is still going.
+const g = globalThis as unknown as { __agentosDoneRunning?: Set<string> };
+const running: Set<string> = (g.__agentosDoneRunning ??= new Set());
 
 // POST /api/sessions/:id/done - finished work: merge through the gates if
-// its PR is open, clean up, archive. 409 with the reason when refused.
+// its PR is open, clean up, archive. 404 for an unknown session, 409 with
+// the reason when refused or already running.
 export async function POST(
   _request: Request,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  let name: string;
+  try {
+    name = getDoneTarget(id).name;
+  } catch {
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  }
+  if (running.has(id))
+    return NextResponse.json(
+      { error: `${name} is already being finished: wait for it to end.` },
+      { status: 409 }
+    );
+  running.add(id);
   try {
-    const outcome = await doneSession((await params).id, {
-      by: "direct",
-      onPeer: true,
-    });
+    const work = doneSession(id, { by: "direct", onPeer: true });
+    work.then(
+      () => running.delete(id),
+      () => running.delete(id)
+    );
+    const outcome = await withinDeadline(work, name);
     return NextResponse.json({ outcome });
   } catch (error) {
+    // A done that threw before it started has nothing left to hold.
+    if (!(error instanceof Error) || !/taking longer/.test(error.message))
+      running.delete(id);
     const message = error instanceof Error ? error.message : String(error);
     return NextResponse.json({ error: message }, { status: 409 });
   }

package/components/SessionList/useDoneAction.test.ts

@@ -0,0 +1,149 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement, useEffect } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Session } from "@/lib/db/types";
+
+const toast = vi.hoisted(() =>
+  Object.assign(vi.fn(), {
+    loading: vi.fn(() => "t1"),
+    success: vi.fn(),
+    error: vi.fn(),
+  })
+);
+vi.mock("sonner", () => ({ toast }));
+
+const { useDoneAction } = await import("./useDoneAction");
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+const hook: { current: (s: Session) => void } = { current: () => {} };
+const confirmSpy = vi.fn(() => false);
+const fetchSpy = vi.fn();
+
+function Probe() {
+  const markDone = useDoneAction();
+  useEffect(() => {
+    hook.current = markDone;
+  });
+  return null;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal("confirm", confirmSpy);
+  vi.stubGlobal("fetch", fetchSpy);
+  host = document.createElement("div");
+  document.body.append(host);
+  root = createRoot(host);
+  act(() =>
+    root.render(
+      createElement(
+        QueryClientProvider,
+        { client: new QueryClient() },
+        createElement(Probe)
+      )
+    )
+  );
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+  vi.unstubAllGlobals();
+});
+
+const quick = {
+  id: "q1",
+  name: "Fix pair page menu label",
+  quick_of: "orch",
+  task_status: "running",
+  pr_status: "open",
+  pr_number: 281,
+} as Session;
+
+const respond = (status: number, body: object) =>
+  fetchSpy.mockResolvedValue({
+    ok: status < 400,
+    status,
+    json: async () => body,
+  });
+// Done on an open PR asks first, in a toast; Merge is its action.
+const confirmMerge = () => {
+  const [, opts] = toast.mock.calls.at(-1) as unknown as [
+    string,
+    { action: { onClick: () => void } },
+  ];
+  act(() => opts.action.onClick());
+};
+const settle = () => act(() => new Promise((r) => setTimeout(r, 0)));
+
+describe("Done from a row's menu", () => {
+  it("asks in the app, not with confirm(), and does nothing until Merge is chosen", async () => {
+    respond(200, {
+      outcome: {
+        id: "q1",
+        name: quick.name,
+        merged: "Merged.",
+        worktree: { action: "none" },
+        text: "Merged. Agent stopped, no worktree.",
+      },
+    });
+    act(() => hook.current(quick));
+    expect(fetchSpy).not.toHaveBeenCalled();
+    confirmMerge();
+    await settle();
+    expect(confirmSpy).not.toHaveBeenCalled();
+    expect(fetchSpy).toHaveBeenCalledWith(
+      "/api/sessions/q1/done",
+      expect.objectContaining({ method: "POST" })
+    );
+    expect(toast.success).toHaveBeenCalledWith(
+      "Merged. Agent stopped, no worktree.",
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("shows a refusal as a toast naming the gate, for a quick change and a task", async () => {
+    respond(409, {
+      error: "Not done, nothing merged.\n- ci failed: CI failed",
+    });
+    act(() => hook.current(quick));
+    confirmMerge();
+    await settle();
+    act(() => hook.current({ ...quick, id: "t2", quick_of: null } as Session));
+    confirmMerge();
+    await settle();
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    expect(toast.error).toHaveBeenCalledTimes(2);
+    expect(toast.error).toHaveBeenCalledWith(
+      expect.stringContaining("ci failed"),
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("ends the Merging toast with an error when the server never answers", async () => {
+    vi.useFakeTimers();
+    fetchSpy.mockImplementation(
+      (_url: string, init: { signal?: AbortSignal }) =>
+        new Promise((_, reject) =>
+          init.signal?.addEventListener("abort", () =>
+            reject(init.signal?.reason)
+          )
+        )
+    );
+    act(() => hook.current(quick));
+    confirmMerge();
+    expect(toast.error).not.toHaveBeenCalled();
+    await act(() => vi.advanceTimersByTimeAsync(181_000));
+    vi.useRealTimers();
+    expect(toast.error).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+});

package/components/SessionList/useDoneAction.ts

@@ -7,21 +7,12 @@ import {
 } from "@/data/done";
 import { useSettleSession } from "@/data/sessions/shelf";
 
-// Done from a session's menu: an open PR merges through the gates, so that
-// one asks first; the rest can be undone from the toast.
+// Done from a session's menu: an open PR merges through the gates, after an
+// in-app confirmation; a failing gate comes back as an error toast naming it.
 export function useDoneAction() {
   const done = useDoneSession();
   const settle = useSettleSession();
-  return (session: Session) => {
-    const merges =
-      session.task_status === "running" && session.pr_status === "open";
-    if (
-      merges &&
-      !confirm(
-        `Merge ${session.name}'s PR through the gates and finish it? A failing gate refuses and nothing merges.`
-      )
-    )
-      return;
+  const run = (session: Session, merges: boolean) => {
     const id = toast.loading(
       merges ? `Merging ${session.name}…` : `Finishing ${session.name}…`
     );
@@ -45,6 +36,20 @@ export function useDoneAction() {
       onError: (e) => toast.error(e.message, { id, duration: 12000 }),
     });
   };
+  return (session: Session) => {
+    const merges =
+      session.task_status === "running" && session.pr_status === "open";
+    if (!merges) return run(session, false);
+    // Merging is the one Done that can't be undone: asked in the app, not
+    // with confirm(), which a webview drops.
+    toast(`Merge ${session.name}'s PR and finish it?`, {
+      description:
+        "It merges only through the orchestrator's gates; a failing gate refuses and nothing merges.",
+      duration: 15000,
+      action: { label: "Merge", onClick: () => run(session, true) },
+      cancel: { label: "Cancel", onClick: () => {} },
+    });
+  };
 }
 
 // Archive from a session's menu: puts it away; Unarchive brings it back.

package/components/Settings/ExperimentsSection.test.ts

@@ -0,0 +1,89 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+for (const key of ["Event", "CustomEvent", "FocusEvent", "HTMLButtonElement"])
+  Object.defineProperty(globalThis, key, {
+    value: (window as unknown as Record<string, unknown>)[key],
+    configurable: true,
+    writable: true,
+  });
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+const w = (calls: number) => ({
+  calls,
+  tokens: calls * 1000,
+  costUsd: calls * 0.01,
+  scripts: 0,
+  shown: 0,
+  accepted: 1,
+  dismissed: 1,
+  acceptRate: 0.5,
+});
+const state = vi.hoisted(() => ({ mutate: vi.fn() }));
+vi.mock("@/data/experiments", () => ({
+  useExperimentsQuery: () => ({
+    isPending: false,
+    isError: false,
+    data: {
+      locked: false,
+      experiments: [
+        {
+          id: "learning-cards",
+          name: "Learning cards",
+          description: "Suggest things when a session ends.",
+          area: "sessions",
+          status: "experimental",
+          suggests: true,
+          on: false,
+          usage: { today: w(1), d7: w(2), d30: w(3) },
+        },
+      ],
+    },
+  }),
+  useSetExperiment: () => ({ mutate: state.mutate }),
+  useExperimentDetailQuery: () => ({ isPending: true }),
+}));
+
+const { ExperimentsSection } = await import("./ExperimentsSection");
+
+let root: Root;
+let host: HTMLDivElement;
+beforeEach(() => {
+  state.mutate.mockReset();
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+});
+
+describe("ExperimentsSection", () => {
+  it("lists each experiment, off, with its usage", () => {
+    act(() => root.render(createElement(ExperimentsSection)));
+    expect(host.textContent).toContain("Learning cards");
+    expect(host.textContent).toContain("Suggest things when a session ends.");
+    expect(host.textContent).toContain("50% (1/2)");
+    expect(
+      host.querySelector('[role="switch"]')?.getAttribute("aria-checked")
+    ).toBe("false");
+  });
+
+  it("turns one on from its toggle", () => {
+    act(() => root.render(createElement(ExperimentsSection)));
+    act(() => {
+      host
+        .querySelector('[role="switch"]')
+        ?.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
+    });
+    expect(state.mutate).toHaveBeenCalledWith(
+      { id: "learning-cards", on: true },
+      expect.any(Object)
+    );
+  });
+});