@saadnvd1/agent-os 0.3.637 → 0.3.644

package/lib/tasks/queue.ts

@@ -66,6 +66,7 @@ export type {
   QueuedTaskView,
   StartOutcome,
 } from "./queue-types";
+import { setTask } from "../db/session-parts";
 export { afterMet, hasFinished, resolveAfter, slotState } from "./queue-rows";
 export { findQueued, listQueue, queuedView } from "./queue-view";
 export { tickOnce, tickQueue, tickQueueSoon } from "./queue-tick";
@@ -260,11 +261,18 @@ export function setPriority(id: string, priority: Priority): void {
       `UPDATE task_queue SET priority = ? WHERE id = ? AND status IN ('queued', 'failed')`
     )
     .run(priority, id).changes;
-  const running = db
-    .prepare(
-      `UPDATE sessions SET priority = ? WHERE id = ? AND task_status IS NOT NULL AND archived_at IS NULL`
-    )
-    .run(priority === DEFAULT_PRIORITY ? null : priority, id).changes;
+  const running = db.transaction(() => {
+    const live = db
+      .prepare(
+        `SELECT 1 FROM session_rows WHERE id = ? AND task_status IS NOT NULL AND archived_at IS NULL`
+      )
+      .get(id);
+    return live
+      ? setTask(db, id, {
+          priority: priority === DEFAULT_PRIORITY ? null : priority,
+        })
+      : false;
+  })();
   if (!queued && !running) throw new Error("No such queued or running task");
   tickQueueSoon();
 }
@@ -272,7 +280,7 @@ export function setPriority(id: string, priority: Priority): void {
 // A task started directly (never queued) keeps the priority it was given.
 export function stampPriority(id: string, priority: Priority | undefined) {
   if (!priority || priority === DEFAULT_PRIORITY) return;
-  db.prepare(`UPDATE sessions SET priority = ? WHERE id = ?`).run(priority, id);
+  setTask(db, id, { priority });
 }
 
 export function removeQueued(id: string): void {

package/lib/tasks/remote-branch.ts

@@ -0,0 +1,170 @@
+// Deleting a task's own branch on GitHub once its PR is merged or closed.
+// Never throws: a branch that stays is a logged line, not a failed merge.
+
+import { git, gitPush } from "../git-exec";
+import { repoSlug } from "../git-remote";
+import { run } from "./gh";
+
+// Never deleted, whatever a setting says.
+export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
+
+export interface BranchDelete {
+  deleted: boolean;
+  why: string;
+}
+
+export interface DeleteBranchOpts {
+  repo: string;
+  branch: string;
+  // The head the PR merged or closed at; the branch goes only if it is still
+  // exactly this commit.
+  prHead: string | null | undefined;
+  // A dropped task that never opened a PR has no head to compare with: its
+  // branch is rejected work and goes whatever it holds.
+  noPr?: boolean;
+  // owner/repo, when known; read from the checkout's origin otherwise.
+  slug?: string | null;
+  // Another open PR in the repo builds on this branch (decided by the caller
+  // when it knows from its own records; GitHub is asked too).
+  hasChildren?: boolean;
+  // Branches this one must never be (the default and base branches).
+  keep?: (string | null | undefined)[];
+}
+
+const gone = (error: unknown) =>
+  /HTTP (404|422)|Not Found|Reference does not exist/i.test(
+    error instanceof Error ? error.message : String(error)
+  );
+
+// repos/o/r/git/ref(s)/heads/<branch>, each path segment encoded.
+export const refPath = (slug: string, branch: string, plural: boolean) =>
+  `repos/${slug}/git/${plural ? "refs" : "ref"}/heads/${branch
+    .split("/")
+    .map(encodeURIComponent)
+    .join("/")}`;
+
+// The branch's commit on GitHub; null when it is gone.
+export async function remoteTip(
+  repo: string,
+  slug: string,
+  branch: string
+): Promise<string | null> {
+  try {
+    const out = await run(
+      "gh",
+      ["api", refPath(slug, branch, false), "--jq", ".object.sha"],
+      repo,
+      20000
+    );
+    return out.trim() || null;
+  } catch (error) {
+    if (gone(error)) return null;
+    throw error;
+  }
+}
+
+// Open PRs targeting the branch: a stacked child, which GitHub would close
+// (and could no longer retarget) if its base vanished.
+export async function openChildren(
+  repo: string,
+  slug: string,
+  branch: string
+): Promise<number[]> {
+  const out = await run(
+    "gh",
+    [
+      "pr",
+      "list",
+      "--repo",
+      slug,
+      "--base",
+      branch,
+      "--state",
+      "open",
+      "--json",
+      "number",
+    ],
+    repo,
+    20000
+  );
+  return (JSON.parse(out) as { number: number }[]).map((p) => p.number);
+}
+
+async function decide(o: DeleteBranchOpts): Promise<BranchDelete> {
+  const { repo, branch, prHead } = o;
+  if (PROTECTED_BRANCHES.has(branch))
+    return { deleted: false, why: "a protected branch" };
+  if (o.keep?.includes(branch))
+    return { deleted: false, why: "it is a base branch" };
+  if (!prHead && !o.noPr)
+    return { deleted: false, why: "no PR head was recorded" };
+  if (o.hasChildren)
+    return { deleted: false, why: "stacked cards still build on it" };
+  const slug = o.slug ?? (await repoSlug(repo));
+  if (!slug) return deleteViaGit(repo, branch, prHead || null);
+
+  const kids = await openChildren(repo, slug, branch);
+  if (kids.length)
+    return {
+      deleted: false,
+      why: `open PR ${kids.map((n) => `#${n}`).join(", ")} is based on it`,
+    };
+  const tip = await remoteTip(repo, slug, branch);
+  if (!tip) return { deleted: false, why: "already gone" };
+  if (prHead && tip !== prHead)
+    return {
+      deleted: false,
+      why: `it moved to ${tip.slice(0, 7)} after the PR's ${prHead.slice(0, 7)}`,
+    };
+  try {
+    await run(
+      "gh",
+      ["api", "-X", "DELETE", refPath(slug, branch, true)],
+      repo,
+      30000
+    );
+  } catch (error) {
+    if (!gone(error)) throw error;
+  }
+  return { deleted: true, why: "deleted" };
+}
+
+// A checkout whose origin isn't on GitHub: ask and delete through git.
+async function deleteViaGit(
+  repo: string,
+  branch: string,
+  prHead: string | null
+): Promise<BranchDelete> {
+  const line = await git(
+    repo,
+    ["ls-remote", "--heads", "origin", `refs/heads/${branch}`],
+    { timeout: 30000 }
+  );
+  const tip = line.trim().split(/\s+/)[0];
+  if (!tip) return { deleted: false, why: "already gone" };
+  if (prHead && tip !== prHead)
+    return {
+      deleted: false,
+      why: `it moved to ${tip.slice(0, 7)} after the PR's ${prHead.slice(0, 7)}`,
+    };
+  await gitPush(repo, ["origin", "--delete", branch], { timeout: 60000 });
+  return { deleted: true, why: "deleted" };
+}
+
+export async function deleteTaskBranch(
+  o: DeleteBranchOpts
+): Promise<BranchDelete> {
+  let result: BranchDelete;
+  try {
+    result = await decide(o);
+  } catch (error) {
+    const text = error instanceof Error ? error.message : String(error);
+    result = {
+      deleted: false,
+      why: `couldn't delete it: ${text.split("\n")[0].slice(0, 200)}`,
+    };
+  }
+  if (!result.deleted)
+    console.log(`[tasks] kept origin/${o.branch}: ${result.why}`);
+  return result;
+}

package/lib/tasks/session.ts

@@ -26,6 +26,7 @@ import {
 import { notifyStatusChanged } from "../status/hub";
 import type { TaskPR } from "./state";
 import { markStatusDirty } from "../status/dirty";
+import { setPr } from "../db/session-parts";
 
 export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
 
@@ -33,7 +34,7 @@ export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
 export function taskSessions(includeArchived = true): Session[] {
   return db
     .prepare(
-      `SELECT ${sessionListColumns(db)} FROM sessions
+      `SELECT ${sessionListColumns(db)} FROM session_rows
          WHERE task_status IS NOT NULL AND task_status != 'moved'
            ${includeArchived ? "" : "AND archived_at IS NULL"}
          ORDER BY created_at DESC`
@@ -205,9 +206,11 @@ export async function prFor(
     if (pr) pushPrChange(session, pr);
   }
   if (pr) {
-    db.prepare(
-      `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`
-    ).run(pr.url, pr.number, pr.state.toLowerCase(), session.id);
+    setPr(db, session.id, {
+      pr_url: pr.url,
+      pr_number: pr.number,
+      pr_status: pr.state.toLowerCase() as "open" | "merged" | "closed",
+    });
     // Merged on GitHub rather than through AgentOS: its log is due too.
     if (pr.state === "MERGED") {
       if (session.pr_status !== "merged") pushMerged(session.id);

package/lib/tasks/start.ts

@@ -107,7 +107,7 @@ export async function finishTaskStart(
   earlier?: TaskSetup
 ): Promise<TaskSetup> {
   const session = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(sessionId) as Session | undefined;
   if (!session?.worktree_path) throw new Error(`No task ${sessionId}`);
   const project = session.project_id ? getProject(session.project_id) : null;
@@ -133,7 +133,7 @@ export async function finishTaskStart(
   // The setup's own error is kept, for the agent's prompt when it launches.
   if (held) return done({ ...setup, status: "held" });
   const now = db
-    .prepare(`SELECT task_status, archived_at FROM sessions WHERE id = ?`)
+    .prepare(`SELECT task_status, archived_at FROM session_rows WHERE id = ?`)
     .get(sessionId) as
     | { task_status: string | null; archived_at: string | null }
     | undefined;
@@ -226,7 +226,7 @@ export async function resumeTaskStarts(
 ): Promise<string[]> {
   const rows = db
     .prepare(
-      `SELECT id, tmux_name, view, setup_ms, setup_error FROM sessions
+      `SELECT id, tmux_name, view, setup_ms, setup_error FROM session_rows
        WHERE setup_status = 'running' AND task_status = 'running'
          AND archived_at IS NULL`
     )
@@ -269,7 +269,7 @@ export async function resumeTaskStarts(
 export function resumeHeldStarts(): string[] {
   const rows = db
     .prepare(
-      `SELECT id, setup_ms, setup_error FROM sessions WHERE setup_status = 'held'
+      `SELECT id, setup_ms, setup_error FROM session_rows WHERE setup_status = 'held'
          AND task_status = 'running' AND archived_at IS NULL`
     )
     .all() as ({ id: string } & SetupColumns)[];

package/lib/tasks/starter.ts

@@ -4,6 +4,7 @@
 
 import path from "path";
 import { db } from "../db";
+import { setPlacement } from "../db/session-parts";
 
 export type StartVia =
   | "session"
@@ -59,7 +60,7 @@ export function callerSession(input: {
   const cwd = path.resolve(input.cwd);
   const rows = db
     .prepare(
-      `SELECT id, role, worktree_path FROM sessions
+      `SELECT id, role, worktree_path FROM session_rows
        WHERE worktree_path IS NOT NULL AND archived_at IS NULL
          AND task_status IS NOT NULL
          AND (host_id IS NULL OR host_id = 'local')`
@@ -111,14 +112,10 @@ export function orchestratorOf(startedBy: string | null | undefined) {
 }
 
 export function recordStart(id: string, s: Starter): void {
-  db.prepare(
-    `UPDATE sessions SET started_by = ?, parent_session_id = (SELECT id FROM sessions WHERE id = ?), started_via = ?,
-       started_by_device = COALESCE(?, started_by_device) WHERE id = ?`
-  ).run(
-    s.startedBy,
-    s.parentSessionId,
-    s.startedVia,
-    s.startedByDevice ?? null,
-    id
-  );
+  db.transaction(() => {
+    db.prepare(
+      `UPDATE sessions SET started_by = ?, parent_session_id = (SELECT id FROM sessions WHERE id = ?), started_via = ? WHERE id = ?`
+    ).run(s.startedBy, s.parentSessionId, s.startedVia, id);
+    setPlacement(db, id, { started_by_device: s.startedByDevice ?? undefined });
+  })();
 }

package/lib/tasks/testing.ts

@@ -1,7 +1,7 @@
 // Test fixtures for task PR lookups: real repositories and worktrees, with
 // gh faked by branch.
 
-import { db, type Session } from "../db";
+import { db, insertSessionRow, type Session } from "../db";
 import { createProject } from "../projects";
 import type { FindPROpts } from "./gh";
 import type { TaskPR } from "./state";
@@ -53,13 +53,19 @@ export function seedTask(
     workingDirectory: repo,
   });
   const id = crypto.randomUUID();
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id,
-       task_status, branch_name, base_branch, worktree_path)
-     VALUES (?, 'Read and execute the brief', ?, ?, ?, 'running', ?, 'main', ?)`
-  ).run(id, `claude-${id}`, worktree, project.id, branch, worktree);
+  insertSessionRow(db, {
+    id,
+    name: "Read and execute the brief",
+    tmux_name: `claude-${id}`,
+    working_directory: worktree,
+    project_id: project.id,
+    task_status: "running",
+    branch_name: branch,
+    base_branch: "main",
+    worktree_path: worktree,
+  });
   return taskRow(id);
 }
 
 export const taskRow = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as Session;
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as Session;

package/lib/usage/calls.ts

@@ -97,7 +97,7 @@ export function sessionContext(sessionId: string): SessionContext {
   const s = db
     .prepare(
       `SELECT name, workspace_id, project_id, model_provider, role, task_status,
-         plan_phase, started_by FROM sessions WHERE id = ?`
+         plan_phase, started_by FROM session_rows WHERE id = ?`
     )
     .get(sessionId) as
     | {

package/lib/usage/compare.ts

@@ -225,7 +225,7 @@ export function taskOutcomes(ids: string[]): Map<string, TaskOutcome> {
   const marks = ids.map(() => "?").join(",");
   const tasks = db
     .prepare(
-      `SELECT id, task_status, plan_decided FROM sessions
+      `SELECT id, task_status, plan_decided FROM session_rows
        WHERE id IN (${marks}) AND task_status IS NOT NULL`
     )
     .all(...ids) as {

package/lib/usage/quality.ts

@@ -82,7 +82,7 @@ export function mergedTasks(from: number, to: number): MergedTask[] {
     db
       .prepare(
         `SELECT id, project_id AS projectId, pr_number AS prNumber, merged_at AS mergedAt
-         FROM sessions WHERE task_status = 'merged' AND merged_at >= ? AND merged_at < ?`
+         FROM session_rows WHERE task_status = 'merged' AND merged_at >= ? AND merged_at < ?`
       )
       .all(sqlTime(from), sqlTime(to)) as MergedTask[]
   ).filter((t) => t.mergedAt);

package/lib/usage/turns.ts

@@ -61,7 +61,7 @@ export function recordTurn(
     const current = db
       .prepare(
         `SELECT name, workspace_id, model, model_provider, role, task_status,
-           plan_phase, started_by FROM sessions WHERE id = ?`
+           plan_phase, started_by FROM session_rows WHERE id = ?`
       )
       .get(session.id) as
       | Pick<

package/lib/voice/vocab.ts

@@ -44,7 +44,7 @@ export function vocabFor(workspaceId: string): string[] {
     workspaceId
   );
   const sessions = names(
-    `SELECT s.name FROM sessions s
+    `SELECT s.name FROM session_rows s
      JOIN projects p ON p.id = s.project_id
      WHERE p.workspace_id = ?
        AND (s.task_status IS NULL OR s.task_status NOT IN ('merged','dropped','done','moved'))

package/lib/worktree-sweep/commits.ts

@@ -0,0 +1,65 @@
+import { getDefaultBranch } from "../git";
+import { git as runGit } from "../git-exec";
+
+const git = (cwd: string, ...args: string[]) =>
+  runGit(cwd, args, { timeout: 60_000 }).then((out) => out.trim());
+
+const lines = (out: string) => out.split("\n").filter(Boolean);
+
+/**
+ * Commits on the worktree's HEAD that nothing else holds: not on any remote
+ * branch, not in the PR a merge took, and with no patch-equivalent commit on
+ * the base or its own remote branch (a rewritten history re-lands the same
+ * changes under new hashes). The shas, so a caller can count and name them.
+ */
+export async function unpushedCommits(
+  worktree: string,
+  repo: string,
+  opts: { prHead?: string | null; branch?: string | null } = {}
+): Promise<string[]> {
+  const head =
+    opts.prHead &&
+    (await git(
+      worktree,
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `${opts.prHead}^{commit}`
+    )
+      .then(() => [opts.prHead!])
+      .catch(() => []));
+  const stray = lines(
+    await git(
+      worktree,
+      "rev-list",
+      "HEAD",
+      "--not",
+      ...(head || []),
+      "--remotes"
+    )
+  );
+  if (!stray.length) return [];
+  const base = await getDefaultBranch(repo).catch(() => "main");
+  const upstreams: string[] = [];
+  for (const ref of [
+    `origin/${base}`,
+    opts.branch && `origin/${opts.branch}`,
+  ]) {
+    if (
+      ref &&
+      (await git(worktree, "rev-parse", "--verify", "--quiet", ref)
+        .then(() => true)
+        .catch(() => false))
+    )
+      upstreams.push(ref);
+  }
+  const left = new Set(stray);
+  for (const ref of upstreams) {
+    if (!left.size) break;
+    // "- <sha>" is a commit the upstream already has the same patch for.
+    const cherry = lines(await git(worktree, "cherry", ref, "HEAD"));
+    for (const l of cherry)
+      if (l.startsWith("- ")) left.delete(l.slice(2).trim());
+  }
+  return [...left];
+}

package/lib/worktree-sweep/findOrphans.ts

@@ -0,0 +1,139 @@
+/**
+ * Folders in the worktrees root that no session owns. Old ones go, after the
+ * same checks as a settled worktree; the throwaway repos tests once left
+ * there (they hold nothing of anyone's) go without them.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { db } from "../db";
+import { mainCheckoutOf } from "../worktrees";
+import { resolveSweepDays } from "./settings";
+import { inFolder } from "./panes";
+import type { Candidate, SweepSkipped } from "./types";
+
+const DAY_MS = 24 * 3600_000;
+
+// What a test's quick-change worktree is called (lib/orchestrator/quick.test.ts).
+const TEST_LEAK = /^(aos-quick-repo-|repo-quick-)/;
+// Kept in a folder AgentOS made that holds no work: placed or rebuilt files.
+const DISPOSABLE = new Set([
+  "node_modules",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  ".git",
+  ".dev-tmux",
+  ".agent-os",
+]);
+
+const real = (p: string) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+};
+
+// Every folder a session row names, on any machine's row: never an orphan.
+function owned(): Set<string> {
+  const rows = db
+    .prepare(
+      `SELECT worktree_path AS a, working_directory AS b FROM session_rows`
+    )
+    .all() as Array<{ a: string | null; b: string | null }>;
+  const out = new Set<string>();
+  for (const r of rows) for (const p of [r.a, r.b]) if (p) out.add(real(p));
+  return out;
+}
+
+// Where a worktree's .git file points; null when it has none.
+function gitdirOf(dir: string): string | null {
+  try {
+    const m = /^gitdir:\s*(.+)$/m.exec(
+      fs.readFileSync(path.join(dir, ".git"), "utf8")
+    );
+    return m ? m[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+const inTemp = (p: string) =>
+  [os.tmpdir(), real(os.tmpdir())].some((t) => inFolder(p, t));
+
+// Nothing in it but what AgentOS placed or rebuilds: no work to lose.
+export const holdsNothing = (dir: string) =>
+  fs
+    .readdirSync(dir)
+    .filter((f) => !DISPOSABLE.has(f))
+    .every((f) => f.startsWith(".env"));
+
+const newestMs = (dir: string) => {
+  let t = 0;
+  for (const p of [dir, path.join(dir, ".git")])
+    try {
+      t = Math.max(t, fs.statSync(p).mtimeMs);
+    } catch {
+      // not there
+    }
+  return t;
+};
+
+export interface OrphanDeps {
+  now: number;
+  root: string;
+  panes: string[];
+}
+
+export async function findOrphans(deps: OrphanDeps): Promise<{
+  candidates: Candidate[];
+  skipped: SweepSkipped[];
+}> {
+  const { days } = resolveSweepDays(null);
+  const candidates: Candidate[] = [];
+  const skipped: SweepSkipped[] = [];
+  if (days === 0 || !fs.existsSync(deps.root)) return { candidates, skipped };
+  const mine = owned();
+  for (const entry of fs.readdirSync(deps.root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const dir = path.join(deps.root, entry.name);
+    if (mine.has(real(dir))) continue;
+    const skip = (reason: string) =>
+      skipped.push({ path: dir, kind: "orphan", reason });
+    if (deps.now - newestMs(dir) < days * DAY_MS) {
+      skip(`touched less than ${days} day${days === 1 ? "" : "s"} ago`);
+      continue;
+    }
+    if (deps.panes.some((p) => inFolder(p, real(dir)) || inFolder(p, dir))) {
+      skip("a terminal is open in it");
+      continue;
+    }
+    const gitdir = gitdirOf(dir);
+    const registered = !!gitdir && fs.existsSync(gitdir);
+    const leak =
+      TEST_LEAK.test(entry.name) &&
+      !!gitdir &&
+      inTemp(real(path.dirname(gitdir)));
+    if (leak) {
+      candidates.push({
+        path: dir,
+        kind: "test-leak",
+        repo: registered ? path.resolve(gitdir!, "../../..") : undefined,
+      });
+      continue;
+    }
+    if (registered) {
+      const repo = await mainCheckoutOf(dir);
+      if (!repo) skip("its repository can't be found");
+      else candidates.push({ path: dir, kind: "orphan", repo });
+      continue;
+    }
+    // Not a git worktree any more: git can't say what's in it.
+    if (holdsNothing(dir)) candidates.push({ path: dir, kind: "orphan" });
+    else skip("it isn't a git worktree and holds files git can't check");
+  }
+  return { candidates, skipped };
+}