@saadnvd1/agent-os 0.3.476 → 0.3.479

package/lib/tasks/index.ts

@@ -96,6 +96,8 @@ export interface TaskView {
   // plan step (lib/models).
   model?: string;
   planning?: boolean;
+  // A quick change: the orchestrator session that makes it (no agent).
+  quickOf?: string | null;
 }
 
 export async function createTask(opts: {
@@ -304,22 +306,31 @@ export async function taskView(session: Session): Promise<TaskView> {
   const setup = taskSetupOf(session);
   // A finished task's PR is in the database: only a running one asks gh.
   const chat = session.view === "chat";
+  // A quick change has no agent: the orchestrator is working on it until
+  // its PR is up, and nothing in it can be blocked.
+  const quick = !!session.quick_of;
   const [pr, chatTurn, screen] = await Promise.all([
     live ? prFor(session) : storedPR(session),
-    live && chat
+    live && chat && !quick
       ? chatStateNow(session.id).catch((): ChatTurn => "unknown")
       : Promise.resolve(null),
-    live && !chat
+    live && !chat && !quick
       ? statusDetector.getStatus(session.tmux_name)
       : Promise.resolve(undefined),
   ]);
   const sessionStatus = !live
     ? undefined
-    : chat
-      ? chatStatus(chatTurn)
-      : screen;
+    : quick
+      ? "running"
+      : chat
+        ? chatStatus(chatTurn)
+        : screen;
   const agentGone =
-    !chat && live && sessionStatus !== "dead" && sessionStatus !== undefined
+    !chat &&
+    !quick &&
+    live &&
+    sessionStatus !== "dead" &&
+    sessionStatus !== undefined
       ? await shellOnly(session.tmux_name)
       : false;
   const blocked =
@@ -365,6 +376,7 @@ export async function taskView(session: Session): Promise<TaskView> {
     armed: !!session.merge_armed_at,
     model: sessionModelRef(session),
     planning: session.plan_phase === "planning",
+    quickOf: session.quick_of ?? null,
   };
 }
 

package/lib/tasks/move-guard.ts

@@ -10,6 +10,8 @@ import { db, type Session } from "../db";
 import { escalations } from "../orchestrator/gates";
 
 export function moveRefusal(session: Session): string | null {
+  if (session.quick_of)
+    return "It's a quick change its orchestrator makes on this machine, so it stays here";
   if (escalations(session.id).length)
     return "It's waiting on you (an escalated gate), so it stays here";
   const ask = db

package/lib/tasks/move.ts

@@ -7,10 +7,9 @@
  */
 
 import os from "os";
-import { execFile } from "child_process";
-import { promisify } from "util";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
+import { endTmuxSession } from "../tmux/end";
 import { launchClaude } from "../agents/launch";
 import { buildTaskBrief } from "./brief";
 import { git as runGit } from "../git-exec";
@@ -31,7 +30,6 @@ import {
 
 export * from "./move-bundle";
 
-const execFileAsync = promisify(execFile);
 const git = (cwd: string, ...args: string[]) =>
   runGit(cwd, args, { timeout: 120000 });
 
@@ -40,9 +38,7 @@ const g = globalThis as unknown as { __agentosExporting?: Set<string> };
 const exporting = (g.__agentosExporting ??= new Set());
 
 async function stopAgent(tmuxName: string): Promise<void> {
-  await execFileAsync("tmux", ["kill-session", "-t", `=${tmuxName}`]).catch(
-    () => undefined
-  );
+  await endTmuxSession(null, tmuxName);
 }
 
 export async function claudeIdFor(session: Session): Promise<string | null> {

package/lib/tasks/pr-poll.ts

@@ -9,7 +9,7 @@ import type { TaskPR } from "./state";
 export const OPEN_TTL_MS = 60_000;
 export const BRANCH_TTL_MS = 5 * 60_000;
 const OPEN_FIELDS =
-  "number,url,state,headRefOid,statusCheckRollup,body,headRefName,isCrossRepository,createdAt,mergeable";
+  "number,url,state,headRefOid,statusCheckRollup,body,headRefName,isCrossRepository,createdAt,mergeable,baseRefName";
 
 interface OpenList {
   at: number;

package/lib/tasks/queue.ts

@@ -110,7 +110,8 @@ const workspaceOf = (projectId: string) =>
   getProject(projectId)?.workspace_id ?? null;
 
 // Running tasks hold their slot until they finish (merged, dropped, done),
-// PR open or not; a queued task being started counts too. Without a
+// PR open or not; a queued task being started counts too. A quick change
+// runs no agent, so it holds none. Without a
 // workspace, the project is the scope.
 function runningIn(scope: { workspaceId: string | null; projectId: string }) {
   const where = scope.workspaceId
@@ -120,7 +121,7 @@ function runningIn(scope: { workspaceId: string | null; projectId: string }) {
     db
       .prepare(
         `SELECT s.id FROM sessions s JOIN projects p ON p.id = s.project_id
-         WHERE ${where} AND s.archived_at IS NULL
+         WHERE ${where} AND s.archived_at IS NULL AND s.quick_of IS NULL
            AND s.task_status IN (${IN_FLIGHT.map((s) => `'${s}'`).join(", ")})`
       )
       .all({ ws: scope.workspaceId, project: scope.projectId }) as {

package/lib/tasks/session.ts

@@ -1,7 +1,10 @@
 import fs from "fs";
 import os from "os";
-import { db, queries, type Session } from "../db";
-import { isBranchName } from "../git";
+import { db, queries, stackQueries, type Session } from "../db";
+import { getDefaultBranch, isBranchName } from "../git";
+import { parentBranchOf } from "../stacks/guard";
+import { voidApprovalsOn } from "../orchestrator/ask-approvals";
+import { taskSubject } from "../orchestrator/asks";
 import { getProject } from "../projects";
 import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
@@ -170,9 +173,67 @@ export async function prFor(
       `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`
     ).run(pr.url, pr.number, pr.state.toLowerCase(), session.id);
   }
+  // Only an answer just read from GitHub: a cached one may predate a
+  // retarget AgentOS made itself (a restack).
+  if (fresh) await recordBase(session, repo, pr);
   return pr;
 }
 
+// An open PR's base as GitHub has it now becomes the task's, in the row and
+// in `session`, so every diff, the stack logic and the UI read the truth:
+// the base recorded at the start goes stale when the PR is retargeted (a
+// stacked parent's branch deleted, so GitHub moved it to main). Only the
+// default branch or the stack parent's branch is taken: a base the task
+// picked itself would choose what its diff is judged against, so it stays
+// unrecorded and sign_off refuses it. Reviews and scope checks judged
+// against the old base no longer count. A stack item on a merged parent
+// keeps its base until the restack moves it, which is also what takes the
+// parent's commits off it.
+// The bases a task may be judged against: the default branch or its stack
+// parent's branch (and what it already has).
+export async function isAllowedBase(
+  session: Session,
+  repo: string,
+  base: string
+): Promise<boolean> {
+  if (base === session.base_branch) return true;
+  const item = stackQueries.itemForSession(db, session.id);
+  const parent = item?.parent_item_id
+    ? stackQueries.item(db, item.parent_item_id)
+    : null;
+  return (
+    base === parentBranchOf(parent) || base === (await getDefaultBranch(repo))
+  );
+}
+
+async function recordBase(
+  session: Session,
+  repo: string,
+  pr: TaskPR | null
+): Promise<void> {
+  const base = pr?.state === "OPEN" ? pr.base : undefined;
+  if (!base || base === session.base_branch || !isBranchName(base)) return;
+  if (!(await isAllowedBase(session, repo, base))) return;
+  const item = stackQueries.itemForSession(db, session.id);
+  const parent = item?.parent_item_id
+    ? stackQueries.item(db, item.parent_item_id)
+    : null;
+  db.transaction(() => {
+    db.prepare(`UPDATE sessions SET base_branch = ? WHERE id = ?`).run(
+      base,
+      session.id
+    );
+    db.prepare(
+      `DELETE FROM orchestrator_checks WHERE session_id = ? AND kind IN ('review', 'scope')`
+    ).run(session.id);
+    // An approval was for the diff against the old base.
+    voidApprovalsOn(taskSubject(session.id));
+    if (item && item.base_branch !== base && parent?.status !== "merged")
+      stackQueries.updateItem(db, item.id, { base_branch: base });
+  })();
+  session.base_branch = base;
+}
+
 // A finished task's PR as the database last saw it: no gh call.
 export function storedPR(s: Session): TaskPR | null {
   if (!s.pr_number) return null;

package/lib/tasks/start.ts

@@ -8,6 +8,7 @@
 
 import { execFile } from "child_process";
 import { promisify } from "util";
+import { endTmuxSession } from "../tmux/end";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { setupWorktree } from "../env-setup";
@@ -195,10 +196,7 @@ function earlierSetup(row: SetupColumns): TaskSetup | undefined {
   return undefined;
 }
 
-export const killTmux = (name: string) =>
-  execFileAsync("tmux", ["kill-session", "-t", `=${name}`], {
-    timeout: 5000,
-  }).catch(() => undefined);
+export const killTmux = (name: string) => endTmuxSession(null, name);
 
 const tmuxAlive = (name: string) =>
   execFileAsync("tmux", ["has-session", "-t", `=${name}`], {

package/lib/tasks/state.ts

@@ -30,6 +30,9 @@ export interface TaskPR {
   // GitHub's word on merging it into its base: CONFLICTING once the base
   // moved under it (UNKNOWN while GitHub works it out).
   mergeable?: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+  // The branch it merges into, as GitHub has it now: it moves when the
+  // PR is retargeted (a stacked parent's branch deleted, say).
+  base?: string;
 }
 
 export type TaskState =

package/lib/tmux/end.ts

@@ -0,0 +1,33 @@
+import { hostExec } from "../hosts";
+import { shellQuote } from "../hosts/ssh";
+import { isValidTmuxName } from "../hosts/tmux-name";
+
+// Run by sh on the machine the session lives on. The pane processes and
+// everything under them are read before tmux ends the session (the kill only
+// hangs up the panes' own shells), then asked to stop and, if any is still
+// there a second later, killed. Only pids found under this session's panes
+// are ever signalled.
+export function endTmuxScript(name: string): string {
+  return [
+    `t=${shellQuote(`=${name}`)}`,
+    `roots=$(tmux list-panes -s -t "$t" -F '#{pane_pid}' 2>/dev/null)`,
+    `tree=$(ps -Ao pid=,ppid= | awk -v roots="$roots" 'BEGIN{n=split(roots,r,/[ \\n]+/);for(i=1;i<=n;i++)if(r[i]!="")s[r[i]]=1} {p[$1]=$2;a[NR]=$1} END{do{c=0;for(i=1;i<=NR;i++){k=a[i];if(!(k in s)&&(p[k] in s)){s[k]=1;c=1}}}while(c);for(k in s)print k}')`,
+    `tmux kill-session -t "$t" 2>/dev/null`,
+    `if [ -n "$tree" ]; then`,
+    `  kill -TERM $tree 2>/dev/null`,
+    `  alive=; for p in $tree; do kill -0 "$p" 2>/dev/null && alive="$alive $p"; done`,
+    `  if [ -n "$alive" ]; then sleep 1; kill -KILL $alive 2>/dev/null; fi`,
+    `fi`,
+    `exit 0`,
+  ].join("\n");
+}
+
+// Ends a tmux session and what its panes started, on the machine it runs on.
+// A session that isn't there is nothing to do; this never throws.
+export async function endTmuxSession(
+  hostId: string | null | undefined,
+  name: string | null | undefined
+): Promise<void> {
+  if (!name || !isValidTmuxName(name)) return;
+  await hostExec(hostId, endTmuxScript(name), 15_000).catch(() => {});
+}

package/lib/tmux/orphans.ts

@@ -0,0 +1,146 @@
+import { db } from "../db";
+import { getManagedSessionPattern } from "../providers/registry";
+import { WORKER_TMUX_PREFIX } from "../chat/worker/protocol";
+import { isValidTmuxName } from "../hosts/tmux-name";
+import { endTmuxSession } from "./end";
+import { tmux } from "./exec";
+
+// tmux sessions AgentOS made whose session row is gone: deleted before every
+// end-of-life path ended the agent. Swept once at start. Only sessions that
+// carry AgentOS's own marks are ever touched: its names (<agent>-<uuid>,
+// aos-chat-<uuid>) or the AGENTOS_SESSION_ID it sets on the session at
+// launch. Dispatch's sessions and anyone's own terminals have neither.
+
+const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const WORKER_NAME = new RegExp(`^${WORKER_TMUX_PREFIX}(${UUID})$`, "i");
+const AGENT_NAME = new RegExp(`(${UUID})$`, "i");
+
+export interface TmuxListing {
+  name: string;
+  // AGENTOS_SESSION_ID on the session itself; null when absent or when the
+  // whole tmux server carries one (every session would then).
+  taggedId: string | null;
+}
+
+export interface SessionRow {
+  id: string;
+  tmux_name: string | null;
+  host_id: string | null;
+}
+
+const isLocal = (hostId: string | null) => !hostId || hostId === "local";
+
+// The AgentOS session id a tmux session belongs to, or null if it isn't one
+// of AgentOS's.
+export function agentOsIdOf(
+  l: TmuxListing,
+  managed = getManagedSessionPattern()
+): string | null {
+  const worker = WORKER_NAME.exec(l.name);
+  if (worker) return worker[1].toLowerCase();
+  if (managed.test(l.name)) return AGENT_NAME.exec(l.name)![1].toLowerCase();
+  return l.taggedId && new RegExp(`^${UUID}$`, "i").test(l.taggedId)
+    ? l.taggedId.toLowerCase()
+    : null;
+}
+
+export function findOrphans(
+  listing: TmuxListing[],
+  rows: SessionRow[]
+): { name: string; id: string }[] {
+  const ids = new Set(rows.map((r) => r.id.toLowerCase()));
+  const names = new Set(
+    rows.filter((r) => isLocal(r.host_id)).map((r) => r.tmux_name)
+  );
+  const orphans: { name: string; id: string }[] = [];
+  for (const l of listing) {
+    const id = agentOsIdOf(l);
+    if (id && !ids.has(id) && !names.has(l.name))
+      orphans.push({ name: l.name, id });
+  }
+  return orphans;
+}
+
+async function taggedId(
+  name: string,
+  serverWide: boolean
+): Promise<string | null> {
+  if (serverWide) return null;
+  const out = await tmux(
+    ["show-environment", "-t", `=${name}`, "AGENTOS_SESSION_ID"],
+    5000
+  ).catch(() => "");
+  return /^AGENTOS_SESSION_ID=(.+)$/m.exec(out)?.[1].trim() ?? null;
+}
+
+async function listLocal(createdBefore: number): Promise<TmuxListing[]> {
+  const out = await tmux(
+    ["list-sessions", "-F", "#{session_created} #{session_name}"],
+    5000
+  ).catch(() => "");
+  // Sessions made after the cutoff belong to work this process started: their
+  // rows may not be committed yet, so they are never candidates.
+  const names = out
+    .split("\n")
+    .map((l) => /^(\d+) (.+)$/.exec(l))
+    .filter((m): m is RegExpExecArray => !!m && Number(m[1]) <= createdBefore)
+    .map((m) => m[2])
+    .filter(isValidTmuxName);
+  // A server started from inside an agent's shell has the variable in its
+  // own environment, which every session on it then shows.
+  const global = await tmux(
+    ["show-environment", "-g", "AGENTOS_SESSION_ID"],
+    5000
+  ).catch(() => "");
+  const serverWide = /^AGENTOS_SESSION_ID=/m.test(global);
+  const managed = getManagedSessionPattern();
+  const listing: TmuxListing[] = [];
+  for (const name of names) {
+    const byName = WORKER_NAME.test(name) || managed.test(name);
+    listing.push({
+      name,
+      taggedId: byName ? null : await taggedId(name, serverWide),
+    });
+  }
+  return listing;
+}
+
+const hasRow = (id: string, tmuxName: string) =>
+  !!db
+    .prepare(`SELECT 1 FROM sessions WHERE id = ? OR tmux_name = ?`)
+    .get(id, tmuxName);
+
+export async function sweepOrphanTmux(
+  opts: {
+    dryRun?: boolean;
+    rows?: SessionRow[];
+    // Epoch seconds; only tmux sessions created at or before it are swept.
+    // Defaults to when this process started.
+    createdBefore?: number;
+  } = {}
+): Promise<{ found: string[]; killed: string[] }> {
+  const none = { found: [], killed: [] };
+  const rows =
+    opts.rows ??
+    (db
+      .prepare(`SELECT id, tmux_name, host_id FROM sessions`)
+      .all() as SessionRow[]);
+  // An empty table is a fresh or wrong database, not proof that nothing is
+  // alive: never sweep against it.
+  if (!rows.length) return none;
+  const cutoff =
+    opts.createdBefore ?? Math.floor(Date.now() / 1000 - process.uptime());
+  const orphans = findOrphans(await listLocal(cutoff), rows);
+  const killed: string[] = [];
+  for (const o of orphans) {
+    if (opts.dryRun) continue;
+    // The snapshot is old by now: a row inserted since keeps its session.
+    if (!opts.rows && hasRow(o.id, o.name)) continue;
+    await endTmuxSession(null, o.name);
+    killed.push(o.name);
+    console.log(`[tmux-sweep] ended ${o.name}: session ${o.id} has no row`);
+  }
+  if (killed.length)
+    console.log(`[tmux-sweep] ended ${killed.length} orphaned tmux sessions`);
+  return { found: orphans.map((o) => o.name), killed };
+}

package/package.json

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

package/server.ts

@@ -61,6 +61,7 @@ import { installClaudeStatusHooks } from "./lib/program-status/claude-hooks";
 import os from "os";
 import { resumeHeldStarts, resumeTaskStarts } from "./lib/tasks/start";
 import { failInterruptedSetups } from "./lib/sessions/worktree-setup";
+import { sweepOrphanTmux } from "./lib/tmux/orphans";
 import { releaseInterruptedClaims } from "./lib/orchestrator/ask-approvals";
 import { resumeReviews } from "./lib/orchestrator/review";
 import { claimAgentosEnv } from "./lib/agents/self-env";
@@ -357,6 +358,14 @@ app.prepare().then(async () => {
   }
   // New sessions whose worktree setup a restart cut off.
   failInterruptedSetups();
+  // tmux sessions of sessions deleted before agents were ended with them.
+  // Production only: a dev or test instance has its own database but shares
+  // the default tmux server, so it would see the real instance's sessions as
+  // orphans.
+  if (!dev && process.env.AGENTOS_TMUX_SWEEP !== "off")
+    sweepOrphanTmux().catch((error) =>
+      console.error("Sweeping orphaned tmux sessions failed:", error)
+    );
   // Chat turns that kept running through a restart.
   void reattachChats();
   // Reviews this restart cut off run again and deliver their verdicts.