@saadnvd1/agent-os 0.3.637 → 0.3.644

package/lib/worktree-sweep/findSettled.ts

@@ -0,0 +1,112 @@
+/**
+ * The sessions whose worktree the sweep may consider: settled, quiet, not
+ * waiting on anyone, no open PR, and old enough for their project's setting.
+ * Everything else is skipped with the reason.
+ */
+
+import fs from "fs";
+import { db, type Session } from "../db";
+import { fromSqliteTime } from "../session-meta";
+import { statusOf } from "../orchestrator/facts";
+import { isAgentOSWorktree } from "../worktrees";
+import { restoring } from "../resurrect/index";
+import { inFolder } from "./panes";
+import { resolveSweepDays } from "./settings";
+import type { Candidate, SweepSkipped } from "./types";
+
+const DAY_MS = 24 * 3600_000;
+const SETTLED_TASKS = new Set(["merged", "dropped", "done"]);
+
+export interface SettledDeps {
+  now: number;
+  panes: string[];
+  status: (s: Session) => ReturnType<typeof statusOf>;
+  isRestoring: (id: string) => boolean;
+}
+
+const ms = (t: string | null | undefined) =>
+  t ? fromSqliteTime(t).getTime() : 0;
+
+// When it settled: the earliest of the marks it carries, else its last update;
+// anything it did afterwards starts the wait again.
+export function settledSinceMs(s: Session): number {
+  const marks = [s.merged_at, s.task_ended_at, s.settled_at, s.archived_at]
+    .map(ms)
+    .filter((t) => t > 0);
+  const settled = marks.length ? Math.min(...marks) : ms(s.updated_at);
+  return Math.max(settled, ms(s.active_at));
+}
+
+export const isSettled = (s: Session) =>
+  s.task_status
+    ? SETTLED_TASKS.has(s.task_status)
+    : !!(s.archived_at || s.settled_at);
+
+function openAsks(): Set<string> {
+  const rows = db
+    .prepare(`SELECT subject FROM orchestrator_asks WHERE status = 'open'`)
+    .all() as Array<{ subject: string }>;
+  return new Set(rows.map((r) => r.subject));
+}
+
+export async function findSettled(
+  deps: SettledDeps
+): Promise<{ candidates: Candidate[]; skipped: SweepSkipped[] }> {
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_rows
+       WHERE worktree_path IS NOT NULL AND worktree_path != ''
+         AND (host_id IS NULL OR host_id = 'local') AND peer_mirror = 0`
+    )
+    .all() as Session[];
+  const asks = openAsks();
+  const candidates: Candidate[] = [];
+  const skipped: SweepSkipped[] = [];
+  for (const s of rows) {
+    const dir = s.worktree_path!;
+    if (!isSettled(s) || !isAgentOSWorktree(dir) || !fs.existsSync(dir))
+      continue;
+    const skip = async (): Promise<string | null> => {
+      if (s.role) return "an orchestrator's";
+      if (s.pinned) return "pinned";
+      if (s.moved_to)
+        return "its task moved to another machine and may come back";
+      if (s.pr_status === "open") return "its PR is open";
+      const { days } = resolveSweepDays(s.project_id);
+      if (days === 0) return "clean-up is off for its project";
+      if (deps.now - settledSinceMs(s) < days * DAY_MS)
+        return `settled less than ${days} day${days === 1 ? "" : "s"} ago`;
+      if (deps.isRestoring(s.id)) return "it is being restored";
+      if (asks.has(`task:${s.id}`)) return "an ask about it is waiting on you";
+      const real = fs.realpathSync(dir);
+      if (deps.panes.some((p) => inFolder(p, real) || inFolder(p, dir)))
+        return "a terminal is open in it";
+      const { status, needsInput } = await deps.status(s);
+      if (needsInput) return "it is waiting on input";
+      if (status !== "idle" && status !== "dead") return `it is ${status}`;
+      return null;
+    };
+    const reason = await skip();
+    if (reason)
+      skipped.push({ path: dir, kind: "settled", reason, sessionId: s.id });
+    else
+      candidates.push({
+        path: dir,
+        kind: "settled",
+        sessionId: s.id,
+        prNumber: s.pr_number,
+        branch: s.branch_name,
+      });
+  }
+  return { candidates, skipped };
+}
+
+export const defaultSettledDeps = (
+  now = Date.now(),
+  panes: string[] = []
+): SettledDeps => ({
+  now,
+  panes,
+  status: statusOf,
+  isRestoring: restoring,
+});

package/lib/worktree-sweep/index.ts

@@ -0,0 +1,10 @@
+export { sweep, describeRun } from "./runSweep";
+export {
+  sweepNow,
+  startWorktreeSweep,
+  sweepEnabled,
+  ownsWorktrees,
+} from "./start";
+export * from "./settings";
+export { recentRuns, sweptAt } from "./store";
+export type * from "./types";

package/lib/worktree-sweep/judge.ts

@@ -0,0 +1,31 @@
+import { describeChanges, unsavedChanges } from "../worktree-placed";
+import { unpushedCommits } from "./commits";
+
+export type Verdict = { remove: true } | { remove: false; reason: string };
+
+/**
+ * Whether removing the worktree would lose anything: uncommitted changes
+ * (except what AgentOS placed and nobody touched), or commits that no remote
+ * branch, merged PR or upstream patch holds. Anything that can't be read
+ * keeps it.
+ */
+export async function judgeWorktree(
+  path: string,
+  repo: string,
+  opts: { prHead?: string | null; branch?: string | null } = {}
+): Promise<Verdict> {
+  const unsaved = await unsavedChanges(path).catch(() => null);
+  if (!unsaved)
+    return { remove: false, reason: "its changes can't be checked" };
+  const stray = await unpushedCommits(path, repo, opts).catch(() => null);
+  if (!stray) return { remove: false, reason: "its commits can't be checked" };
+  const why = [
+    unsaved.length ? `uncommitted changes (${describeChanges(unsaved)})` : null,
+    stray.length
+      ? `${stray.length} commit${stray.length === 1 ? "" : "s"} no remote branch or merged PR has`
+      : null,
+  ].filter((w) => w !== null);
+  return why.length
+    ? { remove: false, reason: why.join(", and ") }
+    : { remove: true };
+}

package/lib/worktree-sweep/panes.ts

@@ -0,0 +1,18 @@
+import { execFile } from "child_process";
+
+// The folders open in tmux panes, so a worktree someone has a terminal in is
+// left alone. Empty when tmux isn't running or can't be read.
+export function openPaneFolders(timeoutMs = 3000): Promise<string[]> {
+  return new Promise((resolve) => {
+    execFile(
+      "tmux",
+      ["list-panes", "-a", "-F", "#{pane_current_path}"],
+      { timeout: timeoutMs },
+      (error, stdout) =>
+        resolve(error ? [] : String(stdout).split("\n").filter(Boolean))
+    );
+  });
+}
+
+export const inFolder = (folder: string, root: string) =>
+  folder === root || folder.startsWith(root + "/");

package/lib/worktree-sweep/runSweep.ts

@@ -0,0 +1,243 @@
+/**
+ * One clean-up run: settled sessions' worktrees and orphan folders, each
+ * judged, removed when nothing would be lost, skipped with a reason when not.
+ * The branch and the conversation stay; a restore rebuilds the worktree.
+ */
+
+import fs from "fs";
+import path from "path";
+import { execFile } from "child_process";
+import { db, type Session } from "../db";
+import { git as runGit } from "../git-exec";
+import { run as runCmd } from "../tasks/gh";
+import { deleteWorktree, WORKTREES_DIR } from "../worktrees";
+import { keepSessionFiles } from "../session-artifacts/collect";
+import { currentLevel } from "../load/monitor";
+import {
+  findSettled,
+  defaultSettledDeps,
+  type SettledDeps,
+} from "./findSettled";
+import { findOrphans, holdsNothing } from "./findOrphans";
+import { judgeWorktree } from "./judge";
+import { openPaneFolders } from "./panes";
+import { finishRun, recordSwept, startRun } from "./store";
+import type { Candidate, SweepSummary } from "./types";
+
+export interface SweepDeps {
+  now: number;
+  root: string;
+  panes: () => Promise<string[]>;
+  settled: Omit<SettledDeps, "now" | "panes">;
+  size: (dir: string) => Promise<number>;
+  prHead: (repo: string, number: number) => Promise<string | null>;
+  // Stop early when the machine is busy.
+  busy: () => boolean;
+}
+
+const git = (cwd: string, ...args: string[]) =>
+  runGit(cwd, args, { timeout: 30_000 }).then((o) => o.trim());
+
+function duBytes(dir: string): Promise<number> {
+  return new Promise((resolve) =>
+    execFile("du", ["-sk", dir], { timeout: 120_000 }, (error, stdout) =>
+      resolve(error ? 0 : (parseInt(String(stdout), 10) || 0) * 1024)
+    )
+  );
+}
+
+async function prHeadOf(repo: string, number: number): Promise<string | null> {
+  try {
+    const out = await runCmd(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(number),
+        "--json",
+        "headRefOid",
+        "-q",
+        ".headRefOid",
+      ],
+      repo,
+      30_000
+    );
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export const defaultSweepDeps = (): SweepDeps => ({
+  now: Date.now(),
+  root: WORKTREES_DIR,
+  panes: openPaneFolders,
+  settled: defaultSettledDeps(),
+  size: duBytes,
+  prHead: prHeadOf,
+  busy: () => currentLevel() === "red",
+});
+
+// A path under the root, never the root itself or something outside it.
+const inRoot = (root: string, p: string) => {
+  const rel = path.relative(path.resolve(root), path.resolve(p));
+  return !!rel && !rel.startsWith("..") && !path.isAbsolute(rel);
+};
+
+async function repoOfSession(c: Candidate): Promise<string | null> {
+  if (c.repo) return c.repo;
+  try {
+    return (
+      await git(
+        c.path,
+        "rev-parse",
+        "--path-format=absolute",
+        "--git-common-dir"
+      )
+    ).replace(/\/\.git\/?$/, "");
+  } catch {
+    return null;
+  }
+}
+
+async function removeOne(
+  c: Candidate,
+  repo: string | null,
+  runId: number
+): Promise<void> {
+  if (c.sessionId) {
+    await keepSessionFiles(c.sessionId).catch(() => {});
+    recordSwept(c.sessionId, c.path, c.branch ?? null, runId);
+  }
+  if (repo && fs.existsSync(repo) && c.kind !== "test-leak")
+    await deleteWorktree(c.path, repo, false).catch(() => {});
+  if (fs.existsSync(c.path))
+    await fs.promises.rm(c.path, { recursive: true, force: true });
+  if (repo && fs.existsSync(repo))
+    await git(repo, "worktree", "prune").catch(() => "");
+}
+
+export async function sweep(
+  opts: { dryRun?: boolean } = {},
+  deps: SweepDeps = defaultSweepDeps()
+): Promise<{ runId: number; summary: SweepSummary }> {
+  const dryRun = !!opts.dryRun;
+  const runId = startRun(dryRun);
+  const summary: SweepSummary = { removed: [], skipped: [], freedBytes: 0 };
+  let error: string | null = null;
+  try {
+    const panes = await deps.panes();
+    const s = await findSettled({ ...deps.settled, now: deps.now, panes });
+    const o = await findOrphans({ now: deps.now, root: deps.root, panes });
+    // Reasons that need a look come before the ones that only need time.
+    const young = (k: { reason: string }) => /less than \d+ day/.test(k.reason);
+    summary.skipped.push(
+      ...[...s.skipped, ...o.skipped].sort(
+        (a, b) => Number(young(a)) - Number(young(b))
+      )
+    );
+    const pruned = new Set<string>();
+    for (const c of [...s.candidates, ...o.candidates]) {
+      if (deps.busy()) {
+        summary.skipped.push({
+          path: c.path,
+          kind: c.kind,
+          reason: "the machine is busy; left for the next run",
+          sessionId: c.sessionId,
+        });
+        continue;
+      }
+      if (!inRoot(deps.root, c.path)) continue;
+      const skip = (reason: string) =>
+        summary.skipped.push({
+          path: c.path,
+          kind: c.kind,
+          reason,
+          sessionId: c.sessionId,
+        });
+      const repo = await repoOfSession(c);
+      const why =
+        c.kind === "test-leak"
+          ? "a test's throwaway repository"
+          : "clean and nothing would be lost";
+      if (c.kind !== "test-leak" && (repo || c.kind === "settled")) {
+        if (!repo) {
+          // Git can't read it: it goes only when it holds nothing of anyone's.
+          if (!holdsNothing(c.path)) {
+            skip("it isn't a git worktree any more");
+            continue;
+          }
+        } else {
+          let verdict = await judgeWorktree(c.path, repo, { branch: c.branch });
+          // A squash merge leaves the branch's commits only in the PR's head.
+          if (!verdict.remove && c.prNumber) {
+            const prHead = await deps.prHead(repo, c.prNumber);
+            if (prHead)
+              verdict = await judgeWorktree(c.path, repo, {
+                branch: c.branch,
+                prHead,
+              });
+          }
+          if (!verdict.remove) {
+            skip(verdict.reason);
+            continue;
+          }
+        }
+      }
+      const bytes = await deps.size(c.path);
+      if (!dryRun) {
+        await removeOne(c, repo, runId);
+        if (fs.existsSync(c.path)) {
+          skip("removing it failed");
+          continue;
+        }
+        if (repo) pruned.add(repo);
+      }
+      summary.removed.push({
+        path: c.path,
+        kind: c.kind,
+        why,
+        bytes,
+        sessionId: c.sessionId,
+      });
+      summary.freedBytes += bytes;
+    }
+    if (!dryRun) await pruneProjects([...pruned]);
+  } catch (e) {
+    error = e instanceof Error ? e.message : String(e);
+  }
+  finishRun(runId, summary, error);
+  console.log(describeRun(summary, dryRun, error));
+  return { runId, summary };
+}
+
+// `git worktree prune` in every repository AgentOS knows, so entries for
+// folders that are gone stop piling up.
+async function pruneProjects(extra: string[]): Promise<void> {
+  const rows = db
+    .prepare(
+      `SELECT working_directory FROM projects WHERE working_directory IS NOT NULL`
+    )
+    .all() as Array<Pick<Session, "working_directory">>;
+  const repos = new Set([...extra, ...rows.map((r) => r.working_directory)]);
+  for (const repo of repos)
+    if (repo && fs.existsSync(repo))
+      await git(repo, "worktree", "prune").catch(() => "");
+}
+
+const gb = (b: number) => `${(b / 1024 ** 3).toFixed(2)} GB`;
+
+export function describeRun(
+  s: SweepSummary,
+  dryRun = false,
+  error: string | null = null
+): string {
+  const reasons = new Map<string, number>();
+  for (const k of s.skipped) {
+    const r = k.reason.replace(/\(.*\)/, "").trim();
+    reasons.set(r, (reasons.get(r) ?? 0) + 1);
+  }
+  const why = [...reasons].map(([r, n]) => `${n} ${r}`).join("; ");
+  const leaks = s.removed.filter((r) => r.kind === "test-leak").length;
+  return `[worktree-sweep] ${dryRun ? "would remove" : "removed"} ${s.removed.length} (${gb(s.freedBytes)}${leaks ? `, ${leaks} test leftovers` : ""}), skipped ${s.skipped.length}${why ? `: ${why}` : ""}${error ? `; failed: ${error}` : ""}`;
+}

package/lib/worktree-sweep/settings.ts

@@ -0,0 +1,83 @@
+/**
+ * How many days a settled worktree stays before the sweep removes it.
+ * Global, with a per-project override; 0 turns it off. Default 7.
+ */
+
+import { z } from "zod";
+import { db } from "../db";
+import type { ResolvedDays } from "./types";
+
+export const DEFAULT_SWEEP_DAYS = 7;
+export const MAX_SWEEP_DAYS = 365;
+
+const GLOBAL_KEY = "worktree_sweep";
+const projectKey = (projectId: string) => `worktree_sweep.project.${projectId}`;
+
+export const sweepDays = z.number().int().min(0).max(MAX_SWEEP_DAYS);
+const stored = z.object({ days: sweepDays });
+
+function read(key: string): number | null {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key) as { value: string } | undefined;
+  if (!row) return null;
+  try {
+    const got = stored.safeParse(JSON.parse(row.value));
+    return got.success ? got.data.days : null;
+  } catch {
+    return null;
+  }
+}
+
+function write(key: string, days: number | null): number | null {
+  if (days === null) {
+    db.prepare(`DELETE FROM settings WHERE key = ?`).run(key);
+    return null;
+  }
+  const got = sweepDays.safeParse(days);
+  if (!got.success)
+    throw new Error(
+      `Days must be a whole number from 0 to ${MAX_SWEEP_DAYS} (0 turns the clean-up off)`
+    );
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(key, JSON.stringify({ days: got.data }));
+  return got.data;
+}
+
+export const globalSweepDays = () => read(GLOBAL_KEY);
+export const setGlobalSweepDays = (days: number | null) =>
+  write(GLOBAL_KEY, days);
+export const projectSweepDays = (projectId: string) =>
+  read(projectKey(projectId));
+export const setProjectSweepDays = (projectId: string, days: number | null) =>
+  write(projectKey(projectId), days);
+
+// The project's own setting, else the global one, else the default.
+export function resolveSweepDays(
+  projectId: string | null | undefined
+): ResolvedDays {
+  const own = projectId ? projectSweepDays(projectId) : null;
+  if (own !== null) return { days: own, from: "project" };
+  const global = globalSweepDays();
+  if (global !== null) return { days: global, from: "global" };
+  return { days: DEFAULT_SWEEP_DAYS, from: "default" };
+}
+
+// Projects with their own number, for the settings page.
+export function projectSweepOverrides(): Array<{
+  projectId: string;
+  days: number;
+}> {
+  const rows = db
+    .prepare(
+      `SELECT key FROM settings WHERE key LIKE 'worktree_sweep.project.%'`
+    )
+    .all() as Array<{ key: string }>;
+  return rows.flatMap(({ key }) => {
+    const projectId = key.slice("worktree_sweep.project.".length);
+    const days = read(key);
+    return days === null ? [] : [{ projectId, days }];
+  });
+}

package/lib/worktree-sweep/start.ts

@@ -0,0 +1,64 @@
+import fs from "fs";
+import path from "path";
+import { dbPath } from "../db/path";
+import { WORKTREES_DIR } from "../worktrees";
+import { sweep } from "./runSweep";
+
+export const SWEEP_EVERY_MS = 6 * 3600_000;
+export const SWEEP_FIRST_AFTER_MS = 10 * 60_000;
+
+const OWNER_FILE = ".sweep-owner";
+
+// A development or test instance has its own database but sees the real
+// worktrees folder: every live worktree would look like an orphan to it. Only
+// a production server, or one asked to, sweeps, and only a folder it owns.
+export const sweepEnabled = (env: NodeJS.ProcessEnv = process.env) =>
+  !env.VITEST &&
+  (env.AGENTOS_WORKTREE_SWEEP === "1" ||
+    (env.NODE_ENV === "production" && env.AGENTOS_WORKTREE_SWEEP !== "0"));
+
+// First sweep claims the folder for this database; another one's claim stands.
+export function ownsWorktrees(
+  claim: boolean,
+  root = WORKTREES_DIR,
+  db = path.resolve(dbPath())
+): boolean {
+  const file = path.join(root, OWNER_FILE);
+  try {
+    return fs.readFileSync(file, "utf8").trim() === db;
+  } catch {
+    // unclaimed
+  }
+  if (!claim) return false;
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(file, db);
+  return true;
+}
+
+const g = globalThis as unknown as { __agentosSweeping?: boolean };
+
+// One run at a time, however it was asked for.
+export async function sweepNow(dryRun = false) {
+  if (g.__agentosSweeping) throw new Error("A clean-up is already running");
+  if (!ownsWorktrees(sweepEnabled()))
+    throw new Error("Another AgentOS owns the worktrees folder");
+  g.__agentosSweeping = true;
+  try {
+    return await sweep({ dryRun });
+  } finally {
+    g.__agentosSweeping = false;
+  }
+}
+
+export function startWorktreeSweep(): void {
+  if (!sweepEnabled()) return;
+  const run = () => {
+    sweepNow().catch((error) =>
+      console.error("[worktree-sweep] not run:", error.message)
+    );
+  };
+  setTimeout(() => {
+    run();
+    setInterval(run, SWEEP_EVERY_MS);
+  }, SWEEP_FIRST_AFTER_MS);
+}

package/lib/worktree-sweep/state.ts

@@ -0,0 +1,36 @@
+import { getAllProjects } from "../projects";
+import {
+  DEFAULT_SWEEP_DAYS,
+  globalSweepDays,
+  projectSweepOverrides,
+} from "./settings";
+import { recentRuns } from "./store";
+import type { SweepRun } from "./types";
+
+export interface SweepState {
+  // Null when no number is set globally: the default applies.
+  days: number | null;
+  defaultDays: number;
+  overrides: Array<{ projectId: string; name: string; days: number }>;
+  runs: SweepRun[];
+}
+
+export function sweepState(): SweepState {
+  const names = new Map(getAllProjects().map((p) => [p.id, p.name]));
+  return {
+    days: globalSweepDays(),
+    defaultDays: DEFAULT_SWEEP_DAYS,
+    overrides: projectSweepOverrides().flatMap((o) =>
+      names.has(o.projectId)
+        ? [
+            {
+              projectId: o.projectId,
+              name: names.get(o.projectId)!,
+              days: o.days,
+            },
+          ]
+        : []
+    ),
+    runs: recentRuns(),
+  };
+}

package/lib/worktree-sweep/store.ts

@@ -0,0 +1,96 @@
+import { db } from "../db";
+import type { SweepRun, SweepSummary } from "./types";
+
+interface RunRow {
+  id: number;
+  started_at: string;
+  finished_at: string | null;
+  dry_run: number;
+  removed: number;
+  freed_bytes: number;
+  skipped: number;
+  details: string | null;
+  error: string | null;
+}
+
+// The counts are exact; the lists kept for a run stop here (a first run can
+// skip thousands of folders that are simply too young).
+const DETAIL_CAP = 300;
+
+const view = (r: RunRow): SweepRun => ({
+  id: r.id,
+  startedAt: r.started_at,
+  finishedAt: r.finished_at,
+  dryRun: !!r.dry_run,
+  removed: r.removed,
+  freedBytes: r.freed_bytes,
+  skipped: r.skipped,
+  details: r.details ? (JSON.parse(r.details) as SweepSummary) : null,
+  error: r.error,
+});
+
+export function startRun(dryRun: boolean): number {
+  return Number(
+    db
+      .prepare(`INSERT INTO worktree_sweep_runs (dry_run) VALUES (?)`)
+      .run(dryRun ? 1 : 0).lastInsertRowid
+  );
+}
+
+export function finishRun(
+  id: number,
+  summary: SweepSummary,
+  error: string | null
+): void {
+  db.prepare(
+    `UPDATE worktree_sweep_runs SET finished_at = datetime('now'), removed = ?,
+       freed_bytes = ?, skipped = ?, details = ?, error = ? WHERE id = ?`
+  ).run(
+    summary.removed.length,
+    summary.freedBytes,
+    summary.skipped.length,
+    JSON.stringify({
+      ...summary,
+      skipped: summary.skipped.slice(0, DETAIL_CAP),
+    }),
+    error,
+    id
+  );
+}
+
+export function recentRuns(limit = 30): SweepRun[] {
+  return (
+    db
+      .prepare(`SELECT * FROM worktree_sweep_runs ORDER BY id DESC LIMIT ?`)
+      .all(limit) as RunRow[]
+  ).map(view);
+}
+
+export function recordSwept(
+  sessionId: string,
+  path: string,
+  branch: string | null,
+  runId: number
+): void {
+  db.prepare(
+    `INSERT INTO session_worktree_sweeps (session_id, path, branch, run_id)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET path = excluded.path,
+       branch = excluded.branch, swept_at = datetime('now'), run_id = excluded.run_id`
+  ).run(sessionId, path, branch, runId);
+}
+
+export function sweptAt(sessionId: string): string | null {
+  const row = db
+    .prepare(
+      `SELECT swept_at FROM session_worktree_sweeps WHERE session_id = ?`
+    )
+    .get(sessionId) as { swept_at: string } | undefined;
+  return row?.swept_at ?? null;
+}
+
+export function forgetSwept(sessionId: string): void {
+  db.prepare(`DELETE FROM session_worktree_sweeps WHERE session_id = ?`).run(
+    sessionId
+  );
+}