@saadnvd1/agent-os 0.3.637 → 0.3.644

package/lib/worktree-sweep/types.ts

@@ -0,0 +1,53 @@
+export type SweepKind = "settled" | "orphan" | "test-leak";
+
+export interface SweepRemoved {
+  path: string;
+  kind: SweepKind;
+  why: string;
+  bytes: number;
+  sessionId?: string;
+}
+
+export interface SweepSkipped {
+  path: string;
+  kind: SweepKind;
+  reason: string;
+  sessionId?: string;
+}
+
+export interface SweepSummary {
+  removed: SweepRemoved[];
+  skipped: SweepSkipped[];
+  freedBytes: number;
+}
+
+export interface SweepRun {
+  id: number;
+  startedAt: string;
+  finishedAt: string | null;
+  dryRun: boolean;
+  removed: number;
+  freedBytes: number;
+  skipped: number;
+  details: SweepSummary | null;
+  error: string | null;
+}
+
+export type DaysSource = "project" | "global" | "default";
+
+export interface ResolvedDays {
+  days: number;
+  from: DaysSource;
+}
+
+// A directory the sweep may remove, once it has been judged.
+export interface Candidate {
+  path: string;
+  kind: SweepKind;
+  sessionId?: string;
+  // The main checkout git knows it by, when it is a registered worktree.
+  repo?: string;
+  // The PR head a merge took, when the session has one.
+  prNumber?: number | null;
+  branch?: string | null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.637",
+  "version": "0.3.644",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/backfill-session-logs.ts

@@ -47,7 +47,7 @@ async function main() {
   const { commitLogs } = await import("../lib/session-logs/hq");
   const rows = db
     .prepare(
-      `SELECT id, name FROM sessions
+      `SELECT id, name FROM session_rows
        WHERE task_prompt IS NOT NULL AND peer_mirror = 0
          AND (task_status = 'merged' OR (pr_status = 'merged' AND task_status != 'dropped'))
        ORDER BY COALESCE(merged_at, updated_at)`

package/scripts/screenshots/seed.ts

@@ -234,7 +234,7 @@ function tmux(args: string[]): void {
 
 async function seedDb(): Promise<void> {
   process.env.DB_PATH = DB_PATH;
-  const { getDb } = await import("../../lib/db");
+  const { getDb, insertSessionRow } = await import("../../lib/db");
   const db = getDb();
   const projectIds = new Map<string, string>();
   const workspaceIds = new Map<string, string>();
@@ -261,24 +261,25 @@ async function seedDb(): Promise<void> {
     sessionIds.set(s.key, id);
     const tmuxName = `claude-${id}`;
     const when = `-${s.minutesAgo} minutes`;
-    db.prepare(
-      `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, agent_type, model, view,
-         task_prompt, task_status, branch_name, base_branch, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, 'claude', 'opus', ?, ?, ?, ?, ?, datetime('now', ?), datetime('now', ?))`
-    ).run(
+    const at = (
+      db.prepare(`SELECT datetime('now', ?) AS t`).get(when) as { t: string }
+    ).t;
+    insertSessionRow(db, {
       id,
-      s.name,
-      tmuxName,
-      `~/code/${s.project}`,
-      projectIds.get(s.project),
-      s.view ?? "terminal",
-      s.task?.prompt ?? null,
-      s.task?.status ?? null,
-      s.task?.branch ?? null,
-      s.task ? "main" : null,
-      when,
-      when
-    );
+      name: s.name,
+      tmux_name: tmuxName,
+      working_directory: `~/code/${s.project}`,
+      project_id: projectIds.get(s.project),
+      agent_type: "claude",
+      model: "opus",
+      view: s.view ?? "terminal",
+      task_prompt: s.task?.prompt ?? null,
+      task_status: s.task?.status ?? null,
+      branch_name: s.task?.branch ?? null,
+      base_branch: s.task ? "main" : null,
+      created_at: at,
+      updated_at: at,
+    });
     if (s.chat) {
       const insert = db.prepare(
         `INSERT INTO chat_items (session_id, item_id, seq, data) VALUES (?, ?, ?, ?)`

package/server.ts

@@ -18,6 +18,7 @@ import { recordBoot } from "./lib/health/boots";
 import { realDeps, schedulesEnabled, startScheduler } from "./lib/schedules";
 import { startSettling } from "./lib/recipes";
 import { startAutoArchive } from "./lib/done/auto-archive";
+import { startWorktreeSweep } from "./lib/worktree-sweep/start";
 import { startUsageRollup, usageRollupEnabled } from "./lib/usage/nightly";
 import { resumePhoneOutbox } from "./lib/notify";
 import { resumePushOutbox } from "./lib/notify/push";
@@ -445,6 +446,8 @@ app.prepare().then(async () => {
   startSettling();
   // Sessions that sat in Done for 30 days are archived.
   startAutoArchive();
+  // Settled worktrees older than the setting are removed; branches stay.
+  startWorktreeSweep();
   resumePhoneOutbox();
   resumePushOutbox();
   // The usage ledger's daily rollup and its ratchet alerts.

package/lib/tasks/held-routes.ts

@@ -1,33 +0,0 @@
-/**
- * The routes only the device that moved a task here may call on it
- * (held.ts): message, stop, done and read. Each is refused for any other
- * device, and for a task that isn't held.
- */
-
-import { NextRequest, NextResponse } from "next/server";
-import { db, type Session } from "../db";
-import { callingDevice } from "../security/device-me";
-import { holderRefusal } from "./held";
-
-type Ctx = { params: Promise<{ id: string }> };
-
-export async function heldRoute(
-  request: NextRequest,
-  { params }: Ctx,
-  run: (task: Session) => Promise<object>
-): Promise<NextResponse> {
-  const id = (await params).id;
-  const task = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
-    | Session
-    | undefined;
-  if (!task?.held_by_device)
-    return NextResponse.json({ error: "No such held task" }, { status: 404 });
-  const refusal = holderRefusal(task, callingDevice(request));
-  if (refusal) return NextResponse.json({ error: refusal }, { status: 403 });
-  try {
-    return NextResponse.json(await run(task));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return NextResponse.json({ error: message }, { status: 409 });
-  }
-}

package/lib/tasks/remote.ts

@@ -1,255 +0,0 @@
-/**
- * Tasks that run on another machine's AgentOS. That machine schedules them;
- * this one keeps a mirror row (same id, the host's id) so the sidebar lists
- * them and the terminal attaches through that machine's AgentOS, and asks it for their
- * state, sign-off and drop.
- */
-
-import { MERGE_METHODS, type MergeMethod } from "./merge-methods";
-import { db, type Project, type Session } from "../db";
-import {
-  HostApiError,
-  hostApi,
-  requireHostLink,
-  type HostLink,
-} from "../hosts/remote-api";
-import { isRemoteHost } from "../hosts";
-import { projectRef } from "./project-ref";
-import { orchestratedStart } from "./held";
-import type { TaskStatus } from "./state";
-import type { TaskView } from "./index";
-import { orchestratorOf } from "./starter";
-
-// What this machine's task API does, for another machine deciding whether
-// it can trust it with a pinned merge or a move; keyed-start: a session
-// start takes a key, so it's safe to retry (lib/sessions/launch.ts).
-export const TASK_CAPABILITIES = [
-  "pinned-merge",
-  "move",
-  "chat-turn",
-  "keyed-start",
-  "chat-move",
-  // Holds an orchestrator's task for the machine that sent it, and answers
-  // its messages, reads, stops and done (lib/tasks/held.ts).
-  "orchestrated-move",
-  // A held task's chat facts and its messages for its orchestrator.
-  "held-chat-facts",
-  "held-replies",
-  // A keyed start that carries an orchestrator's description holds the task
-  // for the device that sent it, as a move does (lib/tasks/held.ts).
-  "held-start",
-  // A plan placed here by another machine stops at the plan for that machine
-  // to decide what follows (lib/tasks/remote-plan.ts).
-  "remote-plan",
-] as const;
-
-export interface HostTasks {
-  tasks: TaskView[];
-  moved?: { id: string; movedTo: string | null }[];
-  capabilities?: string[];
-}
-
-export function isMirror(session: Session): boolean {
-  return isRemoteHost(session.host_id);
-}
-
-export function mirrorTask(
-  hostId: string,
-  projectId: string | null,
-  remote: Session,
-  startedBy?: string | null
-): void {
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, model, group_path,
-       agent_type, auto_approve, project_id, host_id, worktree_path, branch_name,
-       base_branch, task_prompt, task_status, name_source, view)
-     VALUES (?, ?, ?, ?, ?, 'sessions', 'claude', 1, ?, ?, ?, ?, ?, ?, 'running', 'user', ?)
-     ON CONFLICT(id) DO NOTHING`
-  ).run(
-    remote.id,
-    remote.name,
-    remote.tmux_name,
-    remote.working_directory,
-    remote.model,
-    projectId,
-    hostId,
-    remote.worktree_path,
-    remote.branch_name,
-    remote.base_branch,
-    remote.task_prompt,
-    // As that machine runs it: one that predates chat tasks says terminal.
-    remote.view === "chat" ? "chat" : "terminal"
-  );
-  // What carryTaskState gives a moved task's mirror: the orchestrator that
-  // holds it, and when it began (so its PR is judged from then).
-  if (startedBy)
-    db.prepare(
-      `UPDATE sessions SET started_by = COALESCE(started_by, ?),
-         task_since = COALESCE(task_since, created_at) WHERE id = ?`
-    ).run(startedBy, remote.id);
-}
-
-/**
- * A machine on an older AgentOS would take a chat task as a terminal one,
- * or an orchestrator's task as a plain one that anyone there could merge, or
- * refuse to hand one over.
- */
-export async function requireCapability(
-  link: HostLink,
-  capability: string,
-  what: string,
-  verb = "move"
-): Promise<void> {
-  const { capabilities = [] } = await hostTasks(link, true).catch((err) => {
-    throw new Error(
-      `Can't ask ${link.hostName} whether it takes ${what}: ${(err as Error).message}`
-    );
-  });
-  if (!capabilities.includes(capability))
-    throw new Error(
-      `${link.hostName}'s AgentOS can't ${verb} ${what} yet; update it first`
-    );
-}
-
-export const unknownOutcome = (err: unknown) =>
-  err instanceof HostApiError && !err.refused;
-
-/** POST a call that's safe to repeat; once more if we can't tell it landed. */
-export async function postIdempotent<T>(
-  link: HostLink,
-  path: string,
-  body: unknown,
-  timeout: number
-): Promise<T> {
-  try {
-    return await hostApi<T>(link, path, { body, timeout });
-  } catch (err) {
-    if (!unknownOutcome(err)) throw err;
-    return hostApi<T>(link, path, { body, timeout });
-  }
-}
-
-export async function startRemoteTask(
-  hostId: string,
-  project: Project,
-  opts: {
-    id: string;
-    prompt: string;
-    name?: string;
-    model?: string;
-    baseBranch?: string;
-    view?: "chat" | "terminal";
-    // The orchestrator that started it: that machine holds the task for it.
-    startedBy?: string | null;
-    // It plans first: there it plans, stops, and waits for this machine.
-    plan?: { only: boolean; reason: string | null };
-  }
-): Promise<Session> {
-  const link = requireHostLink(hostId);
-  const { startedBy: by, plan, ...rest } = opts;
-  const startedBy = orchestratorOf(by);
-  if (startedBy)
-    await requireCapability(
-      link,
-      "held-start",
-      "an orchestrator's task",
-      "hold"
-    );
-  if (plan) await requireCapability(link, "remote-plan", "a plan step", "plan");
-  const { session } = await postIdempotent<{ session: Session }>(
-    link,
-    "/api/tasks",
-    {
-      project: await projectRef(project),
-      ...rest,
-      ...(plan && {
-        plan: true,
-        plan_only: true,
-        plan_waits: true,
-        plan_reason: plan.reason ?? undefined,
-      }),
-      orchestrated: startedBy ? orchestratedStart(startedBy) : undefined,
-    },
-    180000
-  );
-  mirrorTask(hostId, project.id, session, startedBy);
-  if (plan)
-    db.prepare(
-      `UPDATE sessions SET plan_phase = 'planning', plan_only = ?, plan_decided = 1,
-         plan_reason = ?, plan_waits_for_caller = 1 WHERE id = ?`
-    ).run(plan.only ? 1 : null, plan.reason, session.id);
-  forgetHostTasks(hostId);
-  return db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
-    .get(session.id) as Session;
-}
-
-const cache = new Map<string, { at: number; list: Promise<HostTasks> }>();
-
-export function hostTasks(link: HostLink, fresh = false): Promise<HostTasks> {
-  const hit = cache.get(link.hostId);
-  if (!fresh && hit && Date.now() - hit.at < 3000) return hit.list;
-  const list = hostApi<HostTasks>(link, "/api/tasks", { timeout: 8000 });
-  cache.set(link.hostId, { at: Date.now(), list });
-  list.catch(() => cache.delete(link.hostId));
-  return list;
-}
-
-export const forgetHostTasks = (hostId: string) => cache.delete(hostId);
-
-export function setMirrorStatus(id: string, status: TaskStatus): void {
-  db.prepare(
-    `UPDATE sessions SET task_status = ? WHERE id = ? AND task_status = 'running'`
-  ).run(status, id);
-}
-
-/**
- * Sign off or drop on the machine that runs it. A merge returns the method
- * that machine merged with; null when it doesn't say (an older AgentOS).
- */
-export async function remoteTaskAction(
-  session: Session,
-  action: "merge" | "drop",
-  head?: string,
-  base?: string | null
-): Promise<MergeMethod | null> {
-  const link = requireHostLink(session.host_id);
-  // An AgentOS that predates pinned merges would ignore the head and merge
-  // whatever the PR is at: refuse before asking it.
-  if (head) {
-    const { capabilities = [] } = await hostTasks(link, true);
-    if (!capabilities.includes("pinned-merge"))
-      throw new Error(
-        `${link.hostName}'s AgentOS can't pin a merge to a commit; update it first`
-      );
-  }
-  // base: what the gates here were judged against; the machine that merges
-  // compares the PR with it, not with a base only it recorded.
-  const res = await hostApi<{ head?: string | null; method?: unknown }>(
-    link,
-    `/api/tasks/${encodeURIComponent(session.id)}/${action}`,
-    {
-      body: { ...(head && { head }), ...(head && base && { base }) },
-      timeout: 300000,
-    }
-  ).catch(async (err) => {
-    if (action !== "merge" || !unknownOutcome(err)) throw err;
-    // A proxy or a dropped connection after the merge ran answers 502 with
-    // nothing from AgentOS: ask what state the task is in before failing.
-    const merged = await hostTasks(link, true)
-      .then((l) => l.tasks.find((t) => t.id === session.id)?.state === "merged")
-      .catch(() => false);
-    if (!merged)
-      throw new Error(
-        `${(err as Error).message}: couldn't confirm whether ${link.hostName} merged ${session.name}; check its PR before signing off again`
-      );
-    return { head: head ?? null, method: undefined };
-  });
-  forgetHostTasks(link.hostId);
-  setMirrorStatus(session.id, action === "merge" ? "merged" : "dropped");
-  if (head && res.head !== head)
-    throw new Error(
-      `${link.hostName} merged without confirming it was ${head.slice(0, 7)}`
-    );
-  return MERGE_METHODS.find((m) => m === res.method) ?? null;
-}