@saadnvd1/agent-os 0.3.639 → 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/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>
   );
 }

package/components/Health/SweepRuns.tsx

@@ -0,0 +1,125 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { useRunSweep, useWorktreeSweep } from "@/data/worktree-sweep";
+import { compactTimeAgo, fromSqliteTime } from "@/lib/session-meta";
+import { formatBytes } from "@/lib/share/view";
+import type { SweepRun } from "@/lib/worktree-sweep/types";
+
+const KIND: Record<string, string> = {
+  settled: "settled session",
+  orphan: "orphan folder",
+  "test-leak": "test leftover",
+};
+
+const name = (p: string) => p.split("/").pop();
+
+function Run({ run }: { run: SweepRun }) {
+  const skipped = run.details?.skipped ?? [];
+  const removed = run.details?.removed ?? [];
+  return (
+    <li className="border-border/60 border-b px-3 py-1 last:border-b-0">
+      <details>
+        <summary className="flex min-h-11 cursor-pointer flex-wrap items-center gap-x-3 gap-y-1 text-sm">
+          <span className="font-medium">
+            {run.dryRun ? "Dry run, would remove" : "Removed"} {run.removed}
+          </span>
+          <span className="text-muted-foreground tabular-nums">
+            {formatBytes(run.freedBytes)}
+          </span>
+          <span className="text-muted-foreground">{run.skipped} skipped</span>
+          <span className="text-muted-foreground ml-auto text-xs">
+            {run.finishedAt
+              ? compactTimeAgo(fromSqliteTime(run.finishedAt))
+              : "running"}
+          </span>
+        </summary>
+        {run.error && (
+          <p role="alert" className="text-destructive mt-2 text-sm">
+            {run.error}
+          </p>
+        )}
+        {skipped.length > 0 && (
+          <div className="mt-2 space-y-1 pb-2">
+            <p className="text-sm font-medium">Skipped</p>
+            <ul className="text-muted-foreground space-y-1 text-xs">
+              {skipped.slice(0, 200).map((s) => (
+                <li key={s.path} className="break-all">
+                  {name(s.path)}: {s.reason}
+                </li>
+              ))}
+            </ul>
+          </div>
+        )}
+        {removed.length > 0 && (
+          <div className="mt-2 space-y-1 pb-2">
+            <p className="text-sm font-medium">Removed</p>
+            <ul className="text-muted-foreground space-y-1 text-xs">
+              {removed.slice(0, 200).map((r) => (
+                <li key={r.path} className="break-all">
+                  {name(r.path)} ({KIND[r.kind]}, {formatBytes(r.bytes)})
+                </li>
+              ))}
+            </ul>
+          </div>
+        )}
+      </details>
+    </li>
+  );
+}
+
+// Each worktree clean-up run: what it removed, freed and skipped, and why.
+export function SweepRuns() {
+  const { data, isPending, error } = useWorktreeSweep();
+  const run = useRunSweep();
+  return (
+    <div className="space-y-3">
+      <div className="flex flex-wrap items-center gap-2">
+        <p className="text-muted-foreground min-w-0 flex-1 text-sm">
+          Settled worktrees older than {data?.days ?? data?.defaultDays ?? 7}{" "}
+          days are removed every 6 hours. Branches and conversations stay.
+        </p>
+        <Button
+          variant="outline"
+          className="min-h-11 md:min-h-8"
+          disabled={run.isPending}
+          onClick={() => run.mutate(true)}
+        >
+          Dry run
+        </Button>
+        <Button
+          className="min-h-11 md:min-h-8"
+          disabled={run.isPending}
+          onClick={() => run.mutate(false)}
+        >
+          Run now
+        </Button>
+      </div>
+      {run.error && (
+        <p role="alert" className="text-destructive text-sm">
+          {run.error.message}
+        </p>
+      )}
+      {error && (
+        <p role="alert" className="text-destructive text-sm">
+          {error.message}
+        </p>
+      )}
+      {isPending && (
+        <div className="bg-muted/40 h-24 animate-pulse rounded-xl" />
+      )}
+      {data && data.runs.length === 0 && (
+        <p className="text-muted-foreground text-sm">
+          No run yet. The first one starts 10 minutes after the server does.
+        </p>
+      )}
+      {data && data.runs.length > 0 && (
+        <ul className="border-border/60 overflow-hidden rounded-xl border">
+          {data.runs.map((r) => (
+            <Run key={r.id} run={r} />
+          ))}
+        </ul>
+      )}
+    </div>
+  );
+}

package/components/Merge/GlobalMergeSection.tsx

@@ -11,6 +11,7 @@ import {
 } from "@/lib/tasks/merge-methods";
 import { MergeApprovalToggle } from "./MergeApprovalToggle";
 import { MergeSettingsFields } from "./MergeSettingsFields";
+import { GlobalSweepSection } from "./WorktreeSweepSection";
 
 // "rebase, keeps worktree"
 function describe(s: MergeSettings): string {
@@ -85,6 +86,7 @@ export function GlobalMergeSection() {
         )}
       </div>
       {data && <Overrides overrides={data.overrides} />}
+      <GlobalSweepSection />
     </div>
   );
 }

package/components/Merge/ProjectMergeSection.tsx

@@ -5,6 +5,7 @@ import {
   useUpdateProjectMergeSettings,
 } from "@/data/merge";
 import { MergeSettingsFields } from "./MergeSettingsFields";
+import { ProjectSweepSection } from "./WorktreeSweepSection";
 
 // A project's own merge settings, saved as they change. Unset ones inherit
 // from agentos.json, then the global settings.
@@ -42,6 +43,7 @@ export function ProjectMergeSection({
         <p className="text-destructive text-sm">{update.error.message}</p>
       )}
       <p className="text-muted-foreground text-xs">Saved as you change them.</p>
+      <ProjectSweepSection projectId={projectId} />
     </div>
   );
 }

package/components/Merge/WorktreeSweepSection.tsx

@@ -0,0 +1,125 @@
+"use client";
+
+import { useState } from "react";
+import { Input } from "@/components/ui/input";
+import { useSetSweepDays, useWorktreeSweep } from "@/data/worktree-sweep";
+import { compactTimeAgo, fromSqliteTime } from "@/lib/session-meta";
+import { formatBytes } from "@/lib/share/view";
+
+// Days as the box shows them; empty means "inherit".
+function DaysInput({
+  value,
+  placeholder,
+  disabled,
+  onSave,
+}: {
+  value: number | null;
+  placeholder: string;
+  disabled: boolean;
+  onSave: (days: number | null) => void;
+}) {
+  const [text, setText] = useState(value === null ? "" : String(value));
+  const commit = () => {
+    const raw = text.trim();
+    const next = raw === "" ? null : Number(raw);
+    if (next === value || (next !== null && !Number.isInteger(next))) return;
+    onSave(next);
+  };
+  return (
+    <Input
+      aria-label="Days before a settled worktree is removed"
+      inputMode="numeric"
+      value={text}
+      placeholder={placeholder}
+      disabled={disabled}
+      onChange={(e) => setText(e.target.value)}
+      onBlur={commit}
+      onKeyDown={(e) => e.key === "Enter" && e.currentTarget.blur()}
+      className="h-11 w-24 text-right tabular-nums md:h-9"
+    />
+  );
+}
+
+function LastRun() {
+  const { data } = useWorktreeSweep();
+  const last = data?.runs.find((r) => r.finishedAt && !r.dryRun);
+  if (!last) return null;
+  return (
+    <p className="text-muted-foreground text-xs">
+      Last run {compactTimeAgo(fromSqliteTime(last.finishedAt!))}: removed{" "}
+      {last.removed}, {formatBytes(last.freedBytes)} freed, {last.skipped}{" "}
+      skipped. Details in Health &gt; Clean-up.
+    </p>
+  );
+}
+
+// How long a settled worktree stays on disk. The branch and the conversation
+// stay; restoring the session rebuilds it.
+export function GlobalSweepSection() {
+  const { data, isPending, isError, error } = useWorktreeSweep();
+  const save = useSetSweepDays();
+  return (
+    <div className="space-y-2">
+      <h3 className="text-sm font-medium">Worktree clean-up</h3>
+      <p className="text-muted-foreground text-sm">
+        Remove the worktree of a merged, dropped, done or archived session this
+        many days after it settled, when nothing in it would be lost. 0 turns it
+        off.
+      </p>
+      {isPending && (
+        <div className="bg-muted/40 h-11 animate-pulse rounded-lg" />
+      )}
+      {isError && <p className="text-destructive text-sm">{error.message}</p>}
+      {data && (
+        <div className="flex items-center gap-3">
+          <DaysInput
+            key={data.days ?? "none"}
+            value={data.days}
+            placeholder={String(data.defaultDays)}
+            disabled={save.isPending}
+            onSave={(days) => save.mutate({ days })}
+          />
+          <span className="text-muted-foreground text-sm">days</span>
+        </div>
+      )}
+      {data && data.overrides.length > 0 && (
+        <p className="text-muted-foreground text-xs">
+          Own number:{" "}
+          {data.overrides.map((o) => `${o.name} (${o.days})`).join(", ")}
+        </p>
+      )}
+      {save.isError && (
+        <p className="text-destructive text-sm">{save.error.message}</p>
+      )}
+      <LastRun />
+    </div>
+  );
+}
+
+export function ProjectSweepSection({ projectId }: { projectId: string }) {
+  const { data } = useWorktreeSweep();
+  const save = useSetSweepDays();
+  const own =
+    data?.overrides.find((o) => o.projectId === projectId)?.days ?? null;
+  const inherited = data?.days ?? data?.defaultDays ?? 7;
+  return (
+    <div className="space-y-2">
+      <h3 className="text-sm font-medium">Worktree clean-up</h3>
+      <div className="flex items-center gap-3">
+        <DaysInput
+          key={own ?? "none"}
+          value={own}
+          placeholder={String(inherited)}
+          disabled={!data || save.isPending}
+          onSave={(days) => save.mutate({ days, projectId })}
+        />
+        <span className="text-muted-foreground text-sm">
+          days after a session settles (empty: {inherited}, 0: off)
+        </span>
+      </div>
+      {save.isError && (
+        <p className="text-destructive text-sm">{save.error.message}</p>
+      )}
+    </div>
+  );
+}

package/components/Settings/NoApprovalsSection.tsx

@@ -8,7 +8,7 @@ import { useApprovalsModeQuery, useSetApprovalsMode } from "@/data/approvals";
 // What it switches off, said plainly before it can be switched on.
 export const NO_APPROVALS_WARNING = [
   "Every ask is approved the moment it is raised, hard lines included: public posts and messages, money, irreversible or destructive changes, credentials.",
-  "A PR that failed its gates twice, has no CI, or is too big to review still merges.",
+  "A PR stuck failing its gates, with no CI, or too big to review still merges.",
   "Brakes stop holding new starts, and plan-only tasks go on to implement without waiting for a plan approval.",
   "Every agent AgentOS starts runs with its permission prompts off, and prompts already waiting are allowed.",
 ];

package/components/Settings/SettingsDialog.tsx

@@ -59,7 +59,7 @@ export const SECTION_INFO: Record<
 > = {
   merging: {
     label: "Merging",
-    hint: "Approval, merge method, branch clean-up",
+    hint: "Approval, merge method, branch and worktree clean-up",
     icon: GitMerge,
   },
   approvals: {

package/data/worktree-sweep/index.ts

@@ -0,0 +1,56 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { SweepState } from "@/lib/worktree-sweep/state";
+
+export const sweepKeys = { all: ["worktree-sweep"] as const };
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+export function useWorktreeSweep(enabled = true) {
+  return useQuery({
+    queryKey: sweepKeys.all,
+    queryFn: async () => json<SweepState>(await fetch("/api/worktree-sweep")),
+    enabled,
+    refetchInterval: 60_000,
+  });
+}
+
+export function useSetSweepDays() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (v: { days: number | null; projectId?: string }) =>
+      json<SweepState>(
+        await fetch("/api/worktree-sweep", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(v),
+        })
+      ),
+    onSuccess: (data) => queryClient.setQueryData(sweepKeys.all, data),
+  });
+}
+
+export function useRunSweep() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (dryRun: boolean) =>
+      json<{ started: boolean }>(
+        await fetch("/api/worktree-sweep/run", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ dryRun }),
+        })
+      ),
+    onSuccess: () => {
+      // The run is in the background; look again as it goes.
+      for (const ms of [1500, 8000, 30000])
+        setTimeout(
+          () => queryClient.invalidateQueries({ queryKey: sweepKeys.all }),
+          ms
+        );
+    },
+  });
+}

package/lib/away/report.ts

@@ -92,7 +92,7 @@ export function inFlightWhy(t: {
 }): string {
   const escalated = t.failures.filter((f) => f.escalated_at);
   if (escalated.length)
-    return `with you: the ${escalated.map((f) => f.gate).join(" and ")} gate failed twice`;
+    return `with you: the ${escalated.map((f) => f.gate).join(" and ")} gate kept failing (the loop guard)`;
   if (t.askKinds.length) return `waiting on your answer (${t.askKinds[0]})`;
   const flagged = t.flagged
     ? `; flagged to the orchestrator ${t.flagged}x while you were away`

package/lib/db/backup.ts

@@ -0,0 +1,49 @@
+import type Database from "better-sqlite3";
+import Sqlite from "better-sqlite3";
+import { randomBytes } from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { refuseRealStateUnderTest } from "../test-home-guard";
+
+export const backupsDir = (): string =>
+  refuseRealStateUnderTest(path.join(os.homedir(), ".agent-os", "backups"));
+
+// A full copy of the database (VACUUM INTO) under ~/.agent-os/backups, taken
+// before a destructive migration. Throws, and the migration must stop, unless
+// the copy exists and holds every session. The message never says "already
+// exists": the migration runner reads that as applied.
+export function backupDatabase(
+  db: Database.Database,
+  label: string,
+  dir: string = backupsDir()
+): string {
+  const stamp = new Date().toISOString().replace(/[-:]/g, "").slice(0, 15);
+  const file = path.join(
+    dir,
+    `agent-os-${stamp}-${process.pid}-${randomBytes(3).toString("hex")}-${label}.db`
+  );
+  try {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    db.prepare(`VACUUM INTO ?`).run(file);
+    fs.chmodSync(file, 0o600);
+    const copy = new Sqlite(file, { readonly: true });
+    try {
+      const count = (sql: Database.Database) =>
+        (
+          sql.prepare(`SELECT COUNT(*) AS n FROM sessions`).get() as {
+            n: number;
+          }
+        ).n;
+      if (count(copy) !== count(db)) throw new Error("session count differs");
+    } finally {
+      copy.close();
+    }
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Backup before ${label} failed (${file}): ${reason.replace(/already exists/gi, "is present")}. Nothing was changed.`
+    );
+  }
+  return file;
+}

package/lib/db/migrations/20261015T1733_gate_loop_guard.ts

@@ -0,0 +1,40 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261015T1733_gate_loop_guard",
+  up: (db) => {
+    // The loop guard (orchestrator/loop-guard.ts): how many commits in a row
+    // a gate has failed on, the last failure's signature, whether it repeated
+    // the one before, and the reason the task went to Saad. Additive.
+    const columns = (table: string) =>
+      new Set(
+        (
+          db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[]
+        ).map((c) => c.name)
+      );
+    const failures = columns("orchestrator_gate_failures");
+    if (!failures.has("streak")) {
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN streak INTEGER NOT NULL DEFAULT 0`
+      );
+      // A pass never reset the old count, so it's the most the streak can be.
+      db.exec(`UPDATE orchestrator_gate_failures SET streak = count`);
+    }
+    if (!failures.has("last_signature"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN last_signature TEXT`
+      );
+    if (!failures.has("repeated"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN repeated INTEGER NOT NULL DEFAULT 0`
+      );
+    if (!failures.has("escalated_why"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failures ADD COLUMN escalated_why TEXT`
+      );
+    if (!columns("orchestrator_gate_failure_commits").has("signature"))
+      db.exec(
+        `ALTER TABLE orchestrator_gate_failure_commits ADD COLUMN signature TEXT`
+      );
+  },
+} satisfies Migration;