@saadnvd1/agent-os 0.3.637 → 0.3.644

package/app/api/bus/branches/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDoneTarget } from "@/lib/done";
+import { scopeOf } from "@/lib/done/bulk";
+import { prunableRepos } from "@/lib/tasks/prune-scope";
+import { pruneRepo, pruneText } from "@/lib/tasks/prune-branches";
+
+// `aos branches prune`, from inside a session: reaches only the caller's
+// workspace (or its project when it has none). Lists unless `yes` is true.
+export async function POST(request: NextRequest) {
+  try {
+    const { from = null, yes = false } = await request.json();
+    if (typeof from !== "string" || !from)
+      throw new Error("aos branches runs from inside an AgentOS session");
+    const scope = scopeOf(getDoneTarget(from));
+    const repos = await prunableRepos(scope);
+    if (!repos.length) throw new Error("No GitHub projects in scope");
+    const results = [];
+    for (const repo of repos)
+      results.push(await pruneRepo(repo, { yes: yes === true }));
+    return NextResponse.json({ summary: pruneText(results, yes === true) });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/app/api/bus/resurrect/route.test.ts

@@ -1,4 +1,5 @@
 import { NextRequest } from "next/server";
+import { updateSessionRow } from "@/lib/db";
 import { describe, expect, it, vi } from "vitest";
 
 const resurrect = vi.hoisted(() => vi.fn());
@@ -26,12 +27,8 @@ describe("POST /api/bus/resurrect (aos resurrect)", () => {
   it("reaches only the caller's workspace, and lists what ended with no session", async () => {
     const mine = seedWorkspace("Bus mine");
     const other = seedWorkspace("Bus other");
-    db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
-      mine.task
-    );
-    db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
-      other.task
-    );
+    updateSessionRow(db, mine.task, { task_status: "dropped" });
+    updateSessionRow(db, other.task, { task_status: "dropped" });
     const list = await (await call({ from: mine.chat })).json();
     expect(list.sessions.map((s: { id: string }) => s.id)).toEqual([mine.task]);
 

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

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { getDb, queries, type Session } from "@/lib/db";
+import { getDb, queries, recordPr, type Session } from "@/lib/db";
 import { gitPush } from "@/lib/git-exec";
 
 const execFileAsync = promisify(execFile);
@@ -129,7 +129,7 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
 
     // Update session with PR info if found
     if (pr) {
-      queries.updateSessionPR(db).run(pr.url, pr.number, pr.state, id);
+      recordPr(db, id, pr);
     }
 
     return NextResponse.json({ pr });
@@ -197,7 +197,7 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
     );
 
     // Save PR info to session
-    queries.updateSessionPR(db).run(pr.url, pr.number, pr.state, id);
+    recordPr(db, id, pr);
 
     return NextResponse.json({ pr }, { status: 201 });
   } catch (error) {

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

@@ -16,9 +16,9 @@ export async function GET(
   const { id } = await params;
   const live = getSetup(id);
   if (live) return NextResponse.json({ setup: live });
-  const session = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
-    | Session
-    | undefined;
+  const session = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(id) as Session | undefined;
   if (!session)
     return NextResponse.json({ error: "Session not found" }, { status: 404 });
   const link = isRemoteHost(session.host_id) ? hostLink(session.host_id) : null;

package/app/api/tasks/[id]/approve-plan/route.ts

@@ -1,7 +1,6 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { NextRequest, NextResponse } from "next/server";
 import { approvePlanNow } from "@/lib/models/plan-step";
-import { callingDevice } from "@/lib/security/device-me";
-import { planWaitRefusal } from "@/lib/tasks/held";
 
 // Approves a plan-only task's plan: it continues on the implementation
 // model. An optional message amends the plan (recorded as a scope change).
@@ -10,8 +9,8 @@ export async function POST(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const id = (await params).id;
-  const refusal = planWaitRefusal(id, callingDevice(request));
-  if (refusal) return NextResponse.json({ error: refusal }, { status: 403 });
+  const refused = refuse(request, id, "plan");
+  if (refused) return refused;
   try {
     const body = await request.json().catch(() => ({}));
     const message =

package/app/api/tasks/[id]/arm/route.ts

@@ -1,8 +1,7 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { NextRequest, NextResponse } from "next/server";
 import { db, type Session } from "@/lib/db";
 import { armTask, setArmed } from "@/lib/orchestrator/armed";
-import { callingDevice } from "@/lib/security/device-me";
-import { heldRefusal } from "@/lib/tasks/held";
 
 // { armed: true } merges the task's PR by itself once every gate passes;
 // false takes that back.
@@ -11,8 +10,8 @@ export async function POST(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const id = (await params).id;
-  const held = heldRefusal(id, callingDevice(request));
-  if (held) return NextResponse.json({ error: held }, { status: 403 });
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   const { armed } = await request.json().catch(() => ({}));
   if (typeof armed !== "boolean")
     return NextResponse.json(
@@ -20,7 +19,9 @@ export async function POST(
       { status: 400 }
     );
   const task = db
-    .prepare(`SELECT * FROM sessions WHERE id = ? AND task_status IS NOT NULL`)
+    .prepare(
+      `SELECT * FROM session_rows WHERE id = ? AND task_status IS NOT NULL`
+    )
     .get((await params).id) as Session | undefined;
   if (!task)
     return NextResponse.json({ error: "No such task" }, { status: 404 });

package/app/api/tasks/[id]/chat-facts/route.ts

@@ -2,7 +2,7 @@ import { NextRequest } from "next/server";
 import { blockedReason } from "@/lib/tasks/state";
 import { saidSinceLastMessage } from "@/lib/chat/store";
 import { chatStateNow } from "@/lib/chat/runner";
-import { heldRoute } from "@/lib/tasks/held-routes";
+import { taskRoute } from "@/lib/tasks/contract/authorize";
 
 // GET /api/tasks/:id/chat-facts - what its chat says about being blocked
 // and whether a question is open, for the orchestrator that moved it here.
@@ -11,7 +11,7 @@ export async function GET(
   request: NextRequest,
   ctx: { params: Promise<{ id: string }> }
 ) {
-  return heldRoute(request, ctx, async (task) => {
+  return taskRoute(request, ctx, "holder", async (task) => {
     if (task.view !== "chat") return { blocked: null, turn: null };
     return {
       blocked: blockedReason(saidSinceLastMessage(task.id)),

package/app/api/tasks/[id]/chat-tail/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest } from "next/server";
 import { chatTailText } from "@/lib/orchestrator/read";
-import { heldRoute } from "@/lib/tasks/held-routes";
+import { taskRoute } from "@/lib/tasks/contract/authorize";
 
 // GET /api/tasks/:id/chat-tail?lines= - the last lines of its conversation,
 // for the orchestrator that moved it here to read.
@@ -9,7 +9,7 @@ export async function GET(
   ctx: { params: Promise<{ id: string }> }
 ) {
   const lines = Number(request.nextUrl.searchParams.get("lines")) || 60;
-  return heldRoute(request, ctx, async (task) => ({
+  return taskRoute(request, ctx, "holder", async (task) => ({
     text: task.view === "chat" ? chatTailText(task.id, lines) : "",
   }));
 }

package/app/api/tasks/[id]/checks/route.ts

@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { db, queries, type Session } from "@/lib/db";
 import { taskChecks } from "@/lib/tasks/checks-view";
 import { LoopError, localTask } from "@/lib/tasks/loop-error";
-import { isMirror } from "@/lib/tasks/remote";
+import { isMirror } from "@/lib/tasks/contract/start";
 
 // GET /api/tasks/:id/checks - the PR head's checks, the tail of a failing
 // job's log, and the review gate's verdict on the head. ?log=0 leaves the

package/app/api/tasks/[id]/diff/route.ts

@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { db, queries, type Session } from "@/lib/db";
 import { taskDiff } from "@/lib/tasks/diff";
 import { LoopError, localTask } from "@/lib/tasks/loop-error";
-import { isMirror } from "@/lib/tasks/remote";
+import { isMirror } from "@/lib/tasks/contract/start";
 
 // GET /api/tasks/:id/diff - the task's whole change, base to head: a file
 // list with status and line counts; with ?file=<path>, that file's patch.

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

@@ -1,6 +1,6 @@
 import { NextRequest } from "next/server";
 import { doneSession } from "@/lib/done";
-import { heldRoute } from "@/lib/tasks/held-routes";
+import { taskRoute } from "@/lib/tasks/contract/authorize";
 
 // POST /api/tasks/:id/done - its orchestrator finishes it: the agent stops
 // and the worktree goes. Never a merge (noMerge): an open PR is refused
@@ -9,7 +9,7 @@ export async function POST(
   request: NextRequest,
   ctx: { params: Promise<{ id: string }> }
 ) {
-  return heldRoute(request, ctx, async (task) => ({
+  return taskRoute(request, ctx, "holder", async (task) => ({
     outcome: await doneSession(task.id, { by: "direct", noMerge: true }),
   }));
 }

package/app/api/tasks/[id]/drop/route.ts

@@ -1,12 +1,16 @@
 import { NextRequest, NextResponse } from "next/server";
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { dropTask } from "@/lib/tasks";
 
 export async function POST(
-  _request: NextRequest,
+  request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   try {
-    await dropTask((await params).id);
+    await dropTask(id);
     return NextResponse.json({ success: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/tasks/[id]/export/route.ts

@@ -1,7 +1,6 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { NextRequest, NextResponse } from "next/server";
 import { exportOrResume } from "@/lib/tasks/move";
-import { callingDevice } from "@/lib/security/device-me";
-import { heldRefusal, planWaitRefusal } from "@/lib/tasks/held";
 
 // POST /api/tasks/:id/export - stop the agent, push, hand over the task.
 // The caller confirms with /moved, or restarts it here with /resume; if it
@@ -11,9 +10,8 @@ export async function POST(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const id = (await params).id;
-  const device = callingDevice(request);
-  const held = heldRefusal(id, device) ?? planWaitRefusal(id, device);
-  if (held) return NextResponse.json({ error: held }, { status: 403 });
+  const refused = refuse(request, id, "plan");
+  if (refused) return refused;
   try {
     const { to } = await request.json().catch(() => ({}));
     const bundle = await exportOrResume(

package/app/api/tasks/[id]/merge/route.ts

@@ -1,8 +1,8 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { NextRequest, NextResponse } from "next/server";
 import { signOffTask } from "@/lib/tasks";
 import { callingDevice } from "@/lib/security/device-me";
 import { isBranchName } from "@/lib/git";
-import { heldRefusal } from "@/lib/tasks/held";
 
 // head: merge only if the PR is still at this commit; the answer names the
 // commit it was pinned to, so another machine forwarding a merge can check.
@@ -11,8 +11,8 @@ export async function POST(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const id = (await params).id;
-  const held = heldRefusal(id, callingDevice(request));
-  if (held) return NextResponse.json({ error: held }, { status: 403 });
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   const { head, base } = await request.json().catch(() => ({}));
   if (
     head !== undefined &&

package/app/api/tasks/[id]/message/route.ts

@@ -3,7 +3,7 @@ import { statusDetector } from "@/lib/status-detector";
 import { deliver } from "@/lib/bus";
 import { sendChatConfirmed } from "@/lib/chat/runner";
 import { cleanRemoteText } from "@/lib/hosts/remote-api";
-import { heldRoute } from "@/lib/tasks/held-routes";
+import { taskRoute } from "@/lib/tasks/contract/authorize";
 
 const MAX_LINE = 40_000;
 
@@ -15,7 +15,7 @@ export async function POST(
   ctx: { params: Promise<{ id: string }> }
 ) {
   const body = await request.json().catch(() => ({}));
-  return heldRoute(request, ctx, async (task) => {
+  return taskRoute(request, ctx, "holder", async (task) => {
     const line = typeof body.line === "string" ? body.line.trim() : "";
     if (!line || line.length > MAX_LINE) throw new Error("Bad message");
     const id = typeof body.id === "string" ? body.id.slice(0, 100) : undefined;

package/app/api/tasks/[id]/model/route.ts

@@ -1,3 +1,4 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { NextRequest, NextResponse } from "next/server";
 import { resumeOnModel } from "@/lib/models/resume";
 
@@ -8,10 +9,13 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   const { model, message } = await request.json().catch(() => ({}));
   try {
     const result = await resumeOnModel(
-      (await params).id,
+      id,
       model,
       typeof message === "string" && message.trim() ? message : undefined
     );

package/app/api/tasks/[id]/move/route.ts

@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { moveTask } from "@/lib/tasks";
 import { getProgress } from "@/lib/tasks/move-progress";
 
@@ -7,9 +8,12 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   try {
     const { hostId } = await request.json();
-    const session = await moveTask((await params).id, String(hostId || ""));
+    const session = await moveTask(id, String(hostId || ""));
     return NextResponse.json({ session });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/tasks/[id]/moved/route.ts

@@ -1,7 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { markMoved } from "@/lib/tasks/move";
-import { callingDevice } from "@/lib/security/device-me";
-import { heldRefusal } from "@/lib/tasks/held";
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { cleanUpMovedAway } from "@/lib/tasks/moved-away";
 import { runInBackground } from "@/lib/async-operations";
 
@@ -11,14 +10,13 @@ export async function POST(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const id = (await params).id;
-  const held = heldRefusal(id, callingDevice(request));
-  if (held) return NextResponse.json({ error: held }, { status: 403 });
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   const { to } = await request.json().catch(() => ({}));
   markMoved(id, String(to || "another machine").slice(0, 100));
   // A task its orchestrator took back: its agent and worktree here go.
-  if (held === null)
-    runInBackground(async () => {
-      await cleanUpMovedAway(id);
-    }, `moved-away-${id}`);
+  runInBackground(async () => {
+    await cleanUpMovedAway(id);
+  }, `moved-away-${id}`);
   return NextResponse.json({ success: true });
 }

package/app/api/tasks/[id]/plan/route.ts

@@ -1,9 +1,8 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import fs from "fs/promises";
 import path from "path";
 import { NextRequest, NextResponse } from "next/server";
 import { db, type Session } from "@/lib/db";
-import { callingDevice } from "@/lib/security/device-me";
-import { heldRefusal, planWaitRefusal } from "@/lib/tasks/held";
 import { MAX_PLAN_BYTES } from "@/lib/tasks/move-bundle";
 import { PLAN_FILE } from "@/lib/models/plan-step";
 import { expandHome } from "@/lib/tasks/session";
@@ -15,11 +14,10 @@ export async function GET(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const id = (await params).id;
-  const device = callingDevice(request);
-  const refusal = heldRefusal(id, device) ?? planWaitRefusal(id, device);
-  if (refusal) return NextResponse.json({ error: refusal }, { status: 403 });
+  const refused = refuse(request, id, "plan");
+  if (refused) return refused;
   const s = db
-    .prepare(`SELECT plan_phase, worktree_path FROM sessions WHERE id = ?`)
+    .prepare(`SELECT plan_phase, worktree_path FROM session_rows WHERE id = ?`)
     .get(id) as Pick<Session, "plan_phase" | "worktree_path"> | undefined;
   if (!s?.worktree_path)
     return NextResponse.json({ error: "No such task" }, { status: 404 });

package/app/api/tasks/[id]/plan-edits/route.ts

@@ -1,6 +1,8 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { NextRequest, NextResponse } from "next/server";
 import { db, type Session } from "@/lib/db";
 import { notifyStatusChanged } from "@/lib/status/hub";
+import { setPlan } from "@/lib/db/session-parts";
 
 // Saad's edits to a waiting plan's pieces: which to fold into the one before
 // and which to leave out. Kept on the task and applied when the plan is
@@ -10,6 +12,8 @@ export async function PUT(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const { id } = await params;
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   const body = await request.json().catch(() => ({}));
   const ints = (v: unknown) =>
     Array.isArray(v)
@@ -18,17 +22,14 @@ export async function PUT(
   const merge = ints(body?.merge);
   const drop = ints(body?.drop).filter((n) => !merge.includes(n));
   const session = db
-    .prepare(`SELECT plan_phase FROM sessions WHERE id = ?`)
+    .prepare(`SELECT plan_phase FROM session_rows WHERE id = ?`)
     .get(id) as Pick<Session, "plan_phase"> | undefined;
   if (session?.plan_phase !== "awaiting")
     return NextResponse.json(
       { error: "That task isn't waiting for plan approval" },
       { status: 409 }
     );
-  db.prepare(`UPDATE sessions SET plan_edits = ? WHERE id = ?`).run(
-    JSON.stringify({ merge, drop }),
-    id
-  );
+  setPlan(db, id, { plan_edits: JSON.stringify({ merge, drop }) });
   notifyStatusChanged();
   return NextResponse.json({ success: true, merge, drop });
 }

package/app/api/tasks/[id]/priority/route.ts

@@ -1,4 +1,5 @@
-import { NextResponse } from "next/server";
+import { refuse } from "@/lib/tasks/contract/authorize";
+import { NextRequest, NextResponse } from "next/server";
 import { setPriority } from "@/lib/tasks/queue";
 import { isPriority } from "@/lib/tasks/schedule-types";
 
@@ -9,6 +10,8 @@ export async function PATCH(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const { id } = await params;
+  const refused = refuse(request as NextRequest, id, "open");
+  if (refused) return refused;
   const body = (await request.json().catch(() => null)) as {
     priority?: unknown;
   } | null;

package/app/api/tasks/[id]/resume/route.ts

@@ -1,7 +1,6 @@
+import { refuse } from "@/lib/tasks/contract/authorize";
 import { NextRequest, NextResponse } from "next/server";
 import { resumeHere } from "@/lib/tasks/move-recover";
-import { callingDevice } from "@/lib/security/device-me";
-import { heldRefusal } from "@/lib/tasks/held";
 
 // POST /api/tasks/:id/resume {force?} - start its agent again here, on its
 // conversation. A task left moving asks its target first unless forced.
@@ -10,8 +9,8 @@ export async function POST(
   { params }: { params: Promise<{ id: string }> }
 ) {
   const id = (await params).id;
-  const held = heldRefusal(id, callingDevice(request));
-  if (held) return NextResponse.json({ error: held }, { status: 403 });
+  const refused = refuse(request, id, "open");
+  if (refused) return refused;
   const { force } = await request.json().catch(() => ({}));
   try {
     const result = await resumeHere(id, force === true);

package/app/api/tasks/[id]/stop/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest } from "next/server";
 import { stopSession } from "@/lib/sessions/stop";
-import { heldRoute } from "@/lib/tasks/held-routes";
+import { taskRoute } from "@/lib/tasks/contract/authorize";
 
 // POST /api/tasks/:id/stop - its orchestrator stops the agent; the
 // conversation and worktree are kept.
@@ -8,7 +8,7 @@ export async function POST(
   request: NextRequest,
   ctx: { params: Promise<{ id: string }> }
 ) {
-  return heldRoute(request, ctx, async (task) => ({
+  return taskRoute(request, ctx, "holder", async (task) => ({
     text: await stopSession(task),
   }));
 }

package/app/api/tasks/route.ts

@@ -3,7 +3,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { createTask, listTasks, movedTasks } from "@/lib/tasks";
 import { stampPriority, startOrQueue } from "@/lib/tasks/queue";
 import { isPriority } from "@/lib/tasks/schedule-types";
-import { TASK_CAPABILITIES } from "@/lib/tasks/remote";
+import { TASK_CAPABILITIES } from "@/lib/tasks/contract/types";
 import { ensureProject, type ProjectRef } from "@/lib/tasks/project-ref";
 import { callingDevice } from "@/lib/security/device-me";
 import {

package/app/api/worktree-sweep/route.test.ts

@@ -0,0 +1,40 @@
+import { randomUUID } from "crypto";
+import { describe, expect, it } from "vitest";
+import { NextRequest } from "next/server";
+
+const { GET, PUT } = await import("./route");
+const { createProject } = await import("@/lib/projects");
+
+const put = (body: unknown) =>
+  PUT(
+    new NextRequest("http://localhost/api/worktree-sweep", {
+      method: "PUT",
+      body: JSON.stringify(body),
+    })
+  );
+
+describe("/api/worktree-sweep", () => {
+  it("round-trips the global number and a project's own", async () => {
+    const p = createProject({
+      name: `app-${randomUUID().slice(0, 8)}`,
+      workingDirectory: "/tmp/app",
+    });
+    expect((await (await GET()).json()).days).toBeNull();
+    expect((await (await put({ days: 3 })).json()).days).toBe(3);
+    const state = await (await put({ days: 0, projectId: p.id })).json();
+    expect(state.overrides).toEqual([
+      { projectId: p.id, name: p.name, days: 0 },
+    ]);
+    const cleared = await (await put({ days: null, projectId: p.id })).json();
+    expect(cleared.overrides).toEqual([]);
+    expect((await (await put({ days: null })).json()).days).toBeNull();
+  });
+
+  it("refuses a number that isn't a whole 0-365", async () => {
+    for (const days of [-1, 1.5, 400, "7", undefined]) {
+      const res = await put({ days });
+      expect(res.status).toBe(400);
+    }
+    expect((await put("nope")).status).toBe(400);
+  });
+});

package/app/api/worktree-sweep/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  setGlobalSweepDays,
+  setProjectSweepDays,
+  sweepDays,
+} from "@/lib/worktree-sweep/settings";
+import { sweepState } from "@/lib/worktree-sweep/state";
+
+const body = z.object({
+  // Null clears the setting: the global one, then the default, applies.
+  days: sweepDays.nullable(),
+  projectId: z.string().min(1).optional(),
+});
+
+export async function GET() {
+  return NextResponse.json(sweepState());
+}
+
+export async function PUT(request: NextRequest) {
+  const got = body.safeParse(await request.json().catch(() => null));
+  if (!got.success)
+    return NextResponse.json(
+      { error: "days must be a whole number from 0 to 365, or null" },
+      { status: 400 }
+    );
+  const { days, projectId } = got.data;
+  if (projectId) setProjectSweepDays(projectId, days);
+  else setGlobalSweepDays(days);
+  return NextResponse.json(sweepState());
+}

package/app/api/worktree-sweep/run/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { sweepNow } from "@/lib/worktree-sweep/start";
+
+const body = z.object({ dryRun: z.boolean().optional() });
+
+// Starts a run and answers at once; its result is in the run list.
+export async function POST(request: NextRequest) {
+  const got = body.safeParse(await request.json().catch(() => ({})));
+  if (!got.success)
+    return NextResponse.json(
+      { error: "dryRun must be a boolean" },
+      { status: 400 }
+    );
+  try {
+    const started = new Promise<void>((resolve, reject) => {
+      sweepNow(got.data.dryRun).then(() => resolve(), reject);
+      setTimeout(resolve, 250);
+    });
+    await started;
+    return NextResponse.json({ started: true }, { status: 202 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/components/Health/HealthPanel.tsx

@@ -19,14 +19,16 @@ import {
   type CheckSummary,
 } from "@/lib/health/view";
 import { cn } from "@/lib/utils";
+import { SweepRuns } from "./SweepRuns";
 
-const TABS = ["open", "history", "notes", "thresholds"] as const;
+const TABS = ["open", "history", "notes", "thresholds", "cleanup"] as const;
 type Tab = (typeof TABS)[number];
 const TAB_LABEL: Record<Tab, string> = {
   open: "Open",
   history: "History",
   notes: "Notes",
   thresholds: "Thresholds",
+  cleanup: "Clean-up",
 };
 
 const tokens = (n: number) =>
@@ -407,6 +409,7 @@ export function HealthPanel() {
       )}
       {tab === "notes" && <Notes />}
       {tab === "thresholds" && <Thresholds />}
+      {tab === "cleanup" && <SweepRuns />}
     </div>
   );
 }