@saadnvd1/agent-os 0.3.462 → 0.3.463

package/README.md

@@ -1241,6 +1241,10 @@ scripts/redeploy     # pull, install, build; restarts via $AGENTOS_RESTART only
 scripts/redeploy --rollback  # put the previous build back and restart
 ```
 
+One Node process serves every terminal, chat stream and request, so a route
+handler in `app/api/` may not call a `*Sync` child_process or fs function:
+ESLint refuses it. Use the async form with a timeout.
+
 `scripts/redeploy` (and `scripts/autodeploy`, which calls it) builds into
 `.next-build` while the live server keeps serving `.next`. The build is swapped
 in by rename only once it finished with a `BUILD_ID`, right before the restart.

package/app/api/code-search/available/route.ts

@@ -3,7 +3,7 @@ import { isRipgrepAvailable } from "@/lib/code-search";
 
 export async function GET() {
   try {
-    const available = isRipgrepAvailable();
+    const available = await isRipgrepAvailable();
     return NextResponse.json({ available });
   } catch (error) {
     console.error("Error checking ripgrep availability:", error);

package/app/api/code-search/route.ts

@@ -25,9 +25,11 @@ export async function GET(request: NextRequest) {
 
     const expandedPath = path.replace(/^~/, process.env.HOME || "");
 
-    const rawMatches = searchCode(expandedPath, query, {
-      maxResults,
-      contextLines,
+    // A search the client gave up on (a newer keystroke) stops rg.
+    const rawMatches = await searchCode(expandedPath, query, {
+      maxResults: Number.isFinite(maxResults) ? maxResults : 100,
+      contextLines: Number.isFinite(contextLines) ? contextLines : 2,
+      signal: request.signal,
     });
 
     const results = formatSearchResults(rawMatches);

package/app/api/files/upload-temp/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from "next/server";
-import fs from "fs";
+import { mkdir, writeFile } from "fs/promises";
 import path from "path";
 import os from "os";
 
@@ -13,9 +13,7 @@ export async function POST(request: Request) {
 
     // Create temp directory for screenshots if it doesn't exist
     const tempDir = path.join(os.tmpdir(), "agent-os-screenshots");
-    if (!fs.existsSync(tempDir)) {
-      fs.mkdirSync(tempDir, { recursive: true });
-    }
+    await mkdir(tempDir, { recursive: true });
 
     // Generate unique filename
     const ext = mimeType?.split("/")[1] || "png";
@@ -28,7 +26,7 @@ export async function POST(request: Request) {
 
     // Decode base64 and write file
     const buffer = Buffer.from(base64, "base64");
-    fs.writeFileSync(filePath, buffer);
+    await writeFile(filePath, buffer);
 
     return NextResponse.json({ path: filePath });
   } catch (error) {

package/app/api/git/file-content/route.ts

@@ -1,7 +1,10 @@
 import { NextRequest, NextResponse } from "next/server";
-import { execFileSync } from "child_process";
+import { execFile } from "child_process";
+import { promisify } from "util";
 import { expandPath } from "@/lib/git-status";
 
+const execFileAsync = promisify(execFile);
+
 /**
  * GET /api/git/file-content?path=...&file=...
  * Get file content from git HEAD (original version before changes)
@@ -30,12 +33,17 @@ export async function GET(request: NextRequest) {
 
     try {
       // Get file content from HEAD
-      const content = execFileSync("git", ["show", `HEAD:${file}`], {
-        cwd: expandedPath,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-        maxBuffer: 10 * 1024 * 1024, // 10MB
-      });
+      const { stdout: content } = await execFileAsync(
+        "git",
+        ["show", `HEAD:${file}`],
+        {
+          cwd: expandedPath,
+          encoding: "utf-8",
+          maxBuffer: 10 * 1024 * 1024, // 10MB
+          timeout: 30_000,
+          killSignal: "SIGKILL",
+        }
+      );
 
       return NextResponse.json({ content });
     } catch (gitError: unknown) {

package/app/api/git/pr/route.ts

@@ -11,6 +11,20 @@ import {
   getBaseBranch,
 } from "@/lib/pr";
 import { generatePRContent } from "@/lib/pr-generation";
+import { GhBackoffError } from "@/lib/tasks/gh-limit";
+
+// gh's login, or why it can't be asked now: GitHub's rate limit backs every
+// gh call off, and that isn't a missing login.
+async function ghUnavailable(message: string): Promise<NextResponse | null> {
+  try {
+    if (await checkGhCli()) return null;
+  } catch (error) {
+    if (error instanceof GhBackoffError)
+      return NextResponse.json({ error: error.message }, { status: 503 });
+    throw error;
+  }
+  return NextResponse.json({ error: message }, { status: 400 });
+}
 
 // GET /api/git/pr - Get PR status (fast - no AI generation)
 // Use ?generate=true to also generate suggested title/body (slow - uses Claude CLI)
@@ -30,19 +44,16 @@ export async function GET(request: NextRequest) {
     );
   }
 
-  if (!checkGhCli()) {
-    return NextResponse.json(
-      {
-        error:
-          "GitHub CLI not installed or not authenticated. Run 'gh auth login' first.",
-      },
-      { status: 400 }
-    );
-  }
+  const noGh = await ghUnavailable(
+    "GitHub CLI not installed or not authenticated. Run 'gh auth login' first."
+  );
+  if (noGh) return noGh;
 
   try {
-    const branch = getCurrentBranch(path);
-    const baseBranch = getBaseBranch(path);
+    const [branch, baseBranch] = await Promise.all([
+      getCurrentBranch(path),
+      getBaseBranch(path),
+    ]);
 
     // Check if on main/master (can't create PR from there)
     if (branch === "main" || branch === "master") {
@@ -52,11 +63,11 @@ export async function GET(request: NextRequest) {
       );
     }
 
-    // Check if PR already exists
-    const existingPR = getPRForBranch(path, branch);
-
-    // Get commits for listing
-    const commits = getCommitsSinceBase(path, baseBranch);
+    // The existing PR (network) and the commits since base, side by side.
+    const [existingPR, commits] = await Promise.all([
+      getPRForBranch(path, branch),
+      getCommitsSinceBase(path, baseBranch),
+    ]);
 
     // Only generate suggested content if explicitly requested (for PR creation flow)
     let suggestedTitle: string | undefined;
@@ -87,7 +98,7 @@ export async function GET(request: NextRequest) {
       {
         error: error instanceof Error ? error.message : "Failed to get PR info",
       },
-      { status: 500 }
+      { status: error instanceof GhBackoffError ? 503 : 500 }
     );
   }
 }
@@ -123,15 +134,13 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    if (!checkGhCli()) {
-      return NextResponse.json(
-        { error: "GitHub CLI not installed or not authenticated" },
-        { status: 400 }
-      );
-    }
+    const noGh = await ghUnavailable(
+      "GitHub CLI not installed or not authenticated"
+    );
+    if (noGh) return noGh;
 
-    const branch = getCurrentBranch(path);
-    const baseBranch = customBase || getBaseBranch(path);
+    const branch = await getCurrentBranch(path);
+    const baseBranch = customBase || (await getBaseBranch(path));
 
     // Check if on main/master
     if (branch === "main" || branch === "master") {
@@ -142,7 +151,7 @@ export async function POST(request: NextRequest) {
     }
 
     // Check if PR already exists
-    const existingPR = getPRForBranch(path, branch);
+    const existingPR = await getPRForBranch(path, branch);
     if (existingPR) {
       return NextResponse.json(
         { error: "PR already exists for this branch", pr: existingPR },
@@ -151,14 +160,20 @@ export async function POST(request: NextRequest) {
     }
 
     // Create the PR
-    const pr = createPR(path, branch, baseBranch, title, description || "");
+    const pr = await createPR(
+      path,
+      branch,
+      baseBranch,
+      title,
+      description || ""
+    );
 
     return NextResponse.json({ pr }, { status: 201 });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     return NextResponse.json(
       { error: `Failed to create PR: ${message}` },
-      { status: 500 }
+      { status: error instanceof GhBackoffError ? 503 : 500 }
     );
   }
 }

package/app/api/sessions/[id]/send-keys/route.ts

@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { getDb, queries, type Session } from "@/lib/db";
 import { hostExec, isRemoteHost } from "@/lib/hosts";
 import { shellQuote } from "@/lib/hosts/ssh";
-import { appendFileSync } from "fs";
+import { appendFile } from "fs/promises";
 import { pasteText, tmux } from "@/lib/tmux/exec";
 
 // Log to file for debugging
@@ -11,9 +11,7 @@ function log(msg: string) {
   const timestamp = new Date().toISOString();
   const line = `[${timestamp}] ${msg}\n`;
   console.log(`[send-keys] ${msg}`);
-  try {
-    appendFileSync(LOG_FILE, line);
-  } catch {}
+  appendFile(LOG_FILE, line).catch(() => {});
 }
 
 // POST /api/sessions/[id]/send-keys - Send text to a tmux session

package/app/api/sessions/[id]/summarize/route.ts

@@ -3,7 +3,7 @@ import { isRemoteHost } from "@/lib/hosts";
 import { spawn } from "child_process";
 import { getDb, queries, type Session } from "@/lib/db";
 import { randomUUID } from "crypto";
-import { readFileSync, existsSync } from "fs";
+import { readFile } from "fs/promises";
 import { homedir } from "os";
 import { pasteText, tmux } from "@/lib/tmux/exec";
 
@@ -36,20 +36,26 @@ function encodeProjectPath(cwd: string): string {
 }
 
 // Read and parse Claude session JSONL file
-function readClaudeSessionHistory(
+async function readClaudeSessionHistory(
   cwd: string,
   claudeSessionId: string
-): string | null {
+): Promise<string | null> {
   const projectPath = encodeProjectPath(cwd);
   const jsonlPath = `${homedir()}/.claude/projects/${projectPath}/${claudeSessionId}.jsonl`;
 
-  if (!existsSync(jsonlPath)) {
-    console.log(`[summarize] JSONL not found: ${jsonlPath}`);
+  let content: string;
+  try {
+    content = await readFile(jsonlPath, "utf-8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      console.log(`[summarize] JSONL not found: ${jsonlPath}`);
+      return null;
+    }
+    console.error(`[summarize] Error reading JSONL:`, error);
     return null;
   }
 
   try {
-    const content = readFileSync(jsonlPath, "utf-8");
     const lines = content.trim().split("\n");
     const messages: string[] = [];
 
@@ -240,7 +246,10 @@ export async function POST(
       const claudeSessionId = await getClaudeSessionId(tmuxSessionName);
       if (claudeSessionId && cwdExpanded) {
         console.log(`[summarize] Found Claude session ID: ${claudeSessionId}`);
-        conversation = readClaudeSessionHistory(cwdExpanded, claudeSessionId);
+        conversation = await readClaudeSessionHistory(
+          cwdExpanded,
+          claudeSessionId
+        );
         if (conversation) {
           console.log(
             `[summarize] Read ${conversation.length} chars from JSONL`

package/app/api/sessions/init-script/route.ts

@@ -73,7 +73,7 @@ export async function POST(request: NextRequest) {
     const scriptContent = generateInitScript(agentCommand);
     const scriptPath = path.join(os.tmpdir(), `agent-os-init-${Date.now()}.sh`);
 
-    fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+    await fs.promises.writeFile(scriptPath, scriptContent, { mode: 0o755 });
 
     return NextResponse.json({ scriptPath, command: `bash ${scriptPath}` });
   } catch (error) {

package/data/code-search/queries.ts

@@ -22,7 +22,8 @@ async function fetchRipgrepAvailability(): Promise<boolean> {
 
 async function fetchCodeSearch(
   path: string,
-  query: string
+  query: string,
+  signal?: AbortSignal
 ): Promise<SearchResponse> {
   const params = new URLSearchParams({
     path,
@@ -31,7 +32,7 @@ async function fetchCodeSearch(
     contextLines: "2",
   });
 
-  const res = await fetch(`/api/code-search?${params}`);
+  const res = await fetch(`/api/code-search?${params}`, { signal });
   const data = await res.json();
 
   if (!res.ok) {
@@ -53,7 +54,8 @@ export function useRipgrepAvailable() {
 export function useCodeSearch(path: string, query: string, enabled = false) {
   return useQuery({
     queryKey: codeSearchKeys.search(path, query),
-    queryFn: () => fetchCodeSearch(path, query),
+    // A newer query cancels this one, and the server stops its rg.
+    queryFn: ({ signal }) => fetchCodeSearch(path, query, signal),
     enabled: enabled && query.length > 2,
     staleTime: 30000,
     gcTime: 60000,

package/lib/code-search.ts

@@ -1,15 +1,20 @@
-import { execSync, spawnSync } from "child_process";
+import { execFile, spawn } from "child_process";
+import { createInterface } from "readline";
+
+// rg runs off the event loop: a search over a big tree never stalls the
+// server's other requests. It stops at the result cap, the output cap or the
+// timeout, whichever comes first, and when the caller aborts.
+export const SEARCH_TIMEOUT_MS = 10_000;
+export const MAX_RESULTS_CAP = 500;
+const MAX_OUTPUT_BYTES = 5 * 1024 * 1024;
 
 /**
  * Check if ripgrep is available on the system
  */
-export function isRipgrepAvailable(): boolean {
-  try {
-    execSync("which rg", { encoding: "utf-8", stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
+export function isRipgrepAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    execFile("which", ["rg"], { timeout: 5000 }, (error) => resolve(!error));
+  });
 }
 
 export interface SearchOptions {
@@ -17,6 +22,9 @@ export interface SearchOptions {
   contextLines?: number;
   filePattern?: string;
   caseSensitive?: boolean;
+  /** Stops rg (the request went away). */
+  signal?: AbortSignal;
+  timeoutMs?: number;
 }
 
 export interface SearchMatch {
@@ -38,71 +46,89 @@ export interface FormattedMatch {
   lineText: string;
 }
 
-export function searchCode(
+export async function searchCode(
   workingDir: string,
   query: string,
   options: SearchOptions = {}
-): SearchMatch[] {
-  const { maxResults = 100, contextLines = 2 } = options;
+): Promise<SearchMatch[]> {
+  const { contextLines = 2, signal, timeoutMs = SEARCH_TIMEOUT_MS } = options;
+  const maxResults = Math.min(options.maxResults ?? 100, MAX_RESULTS_CAP);
 
-  try {
-    const args = [
-      "--json",
-      `--max-count=${Math.ceil(maxResults / 10)}`,
-      `--context=${contextLines}`,
-      "--ignore-case",
-      // -e: a query starting with "-" is a pattern, never an option (--pre).
-      "-e",
-      query,
-      "--",
-      ".", // CRITICAL: Tell ripgrep to search current directory explicitly
-    ];
+  const args = [
+    "--json",
+    `--max-count=${Math.ceil(maxResults / 10)}`,
+    `--context=${contextLines}`,
+    "--ignore-case",
+    // -e: a query starting with "-" is a pattern, never an option (--pre).
+    "-e",
+    query,
+    "--",
+    ".", // CRITICAL: Tell ripgrep to search current directory explicitly
+  ];
 
-    const result = spawnSync("rg", args, {
+  return new Promise<SearchMatch[]>((resolve, reject) => {
+    const matches: SearchMatch[] = [];
+    // Ignore stdin so ripgrep doesn't wait for it.
+    const rg = spawn("rg", args, {
       cwd: workingDir,
-      encoding: "utf-8",
-      timeout: 10000,
-      maxBuffer: 1024 * 1024 * 5,
-      stdio: ["ignore", "pipe", "pipe"], // Ignore stdin so ripgrep doesn't wait for it
+      stdio: ["ignore", "pipe", "ignore"],
     });
+    let bytes = 0;
+    let stopped = false;
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      rg.kill("SIGKILL");
+    };
+    const timer = setTimeout(stop, timeoutMs);
+    signal?.addEventListener("abort", stop, { once: true });
+    if (signal?.aborted) stop();
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", stop);
+    };
 
-    if (result.error) {
-      throw result.error;
-    }
-
-    // Status 1 = no matches (not an error for ripgrep)
-    if (result.status !== 0 && result.status !== 1) {
-      return [];
-    }
-
-    const output = result.stdout || "";
-    const matches: SearchMatch[] = [];
-    const lines = output.trim().split("\n").filter(Boolean);
-
-    for (const line of lines) {
+    rg.stdout.on("data", (chunk: Buffer) => {
+      bytes += chunk.length;
+      if (bytes > MAX_OUTPUT_BYTES) stop();
+    });
+    const lines = createInterface({ input: rg.stdout, crlfDelay: Infinity });
+    lines.on("line", (line) => {
+      // What rg printed before a stop still counts, up to the cap.
+      if (!line || matches.length >= maxResults) return;
       try {
         const parsed = JSON.parse(line);
-        if (parsed.type === "match") {
-          matches.push(parsed);
-          if (matches.length >= maxResults) break;
-        }
+        if (parsed.type !== "match") return;
+        matches.push(parsed);
+        if (matches.length >= maxResults) stop();
       } catch {
-        continue;
+        // A line cut off at the output cap.
       }
-    }
+    });
 
-    return matches;
-  } catch (error) {
-    console.error("Error in searchCode:", error);
-    // ENOENT = command not found
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      throw new Error(
-        "ripgrep (rg) not found. Install with: brew install ripgrep"
-      );
-    }
-    // Other errors - return empty
-    return [];
-  }
+    rg.on("error", (error: NodeJS.ErrnoException) => {
+      done();
+      // ENOENT = command not found
+      if (error.code === "ENOENT") {
+        reject(
+          new Error(
+            "ripgrep (rg) not found. Install with: brew install ripgrep"
+          )
+        );
+        return;
+      }
+      console.error("Error in searchCode:", error);
+      resolve([]);
+    });
+    // "close": stdout is drained, so every line has been read.
+    rg.on("close", (code) => {
+      done();
+      // What it found before a cap, the timeout or an abort stopped it.
+      if (stopped) return resolve(matches);
+      // Status 1 = no matches (not an error for ripgrep)
+      resolve(code === 0 || code === 1 ? matches : []);
+    });
+  });
 }
 
 export function formatSearchResults(matches: SearchMatch[]): FormattedMatch[] {

package/lib/db/queries.ts

@@ -28,6 +28,13 @@ export const queries = {
   getAllSessions: (db: Database.Database) =>
     getStmt(db, `SELECT * FROM sessions ORDER BY updated_at DESC`),
 
+  // The tmux names AgentOS owns, for telling discovered sessions apart.
+  getManagedTmuxNames: (db: Database.Database) =>
+    getStmt(
+      db,
+      `SELECT host_id, tmux_name FROM sessions WHERE tmux_name IS NOT NULL AND tmux_name != ''`
+    ),
+
   updateSessionStatus: (db: Database.Database) =>
     getStmt(
       db,
@@ -196,6 +203,12 @@ export const queries = {
   getProject: (db: Database.Database) =>
     getStmt(db, `SELECT * FROM projects WHERE id = ?`),
 
+  getProjectFolders: (db: Database.Database) =>
+    getStmt(
+      db,
+      `SELECT id, host_id, working_directory, is_uncategorized FROM projects`
+    ),
+
   getAllProjects: (db: Database.Database) =>
     getStmt(
       db,

package/lib/hosts/discover-signature.ts

@@ -1,19 +1,50 @@
-import { getDb, queries, type Project, type Session } from "../db";
+import { getDb, queries } from "../db";
 import { statusDetector } from "../status-detector";
-import { discoverSessions } from "./discover";
+import {
+  discoverSessions,
+  type ManagedTmux,
+  type ProjectFolder,
+} from "./discover";
 
 // What the discovered-sessions list shows, minus activity times: when this
 // changes, browsers refetch /api/tmux/discover (pushed as "discovered").
 // Reads the status detector's last list-sessions, so it runs no tmux.
+//
+// The status hub asks once a second while anyone watches. The answer only
+// moves when the sessions or projects tables are written or tmux is listed
+// anew, so it's recomputed only then, from the columns matching reads.
+let last: { versions: string; listing: object; signature: string } | null =
+  null;
+
+function tableVersions(): string {
+  const rows = getDb()
+    .prepare(
+      `SELECT topic, version FROM change_versions WHERE topic IN ('sessions', 'projects') ORDER BY topic`
+    )
+    .all() as { topic: string; version: number }[];
+  return rows.map((r) => `${r.topic}:${r.version}`).join(",");
+}
+
 export function discoveredSignature(): string {
+  const versions = tableVersions();
+  const listing = statusDetector.listingStamp();
+  if (last && last.versions === versions && last.listing === listing)
+    return last.signature;
   const db = getDb();
   const found = discoverSessions(
     statusDetector.cachedSessions(),
-    queries.getAllProjects(db).all() as Project[],
-    queries.getAllSessions(db).all() as Session[]
+    queries.getProjectFolders(db).all() as ProjectFolder[],
+    queries.getManagedTmuxNames(db).all() as ManagedTmux[]
   );
-  return JSON.stringify([
+  const signature = JSON.stringify([
     found.map((s) => [s.hostId, s.name, s.projectId, s.path]).sort(),
     statusDetector.hostErrors(),
   ]);
+  last = { versions, listing, signature };
+  return signature;
+}
+
+/** Forget the remembered answer (tests). */
+export function resetDiscoveredSignature(): void {
+  last = null;
 }

package/lib/hosts/discover.ts

@@ -27,8 +27,15 @@ const hostKey = (hostId: string | null | undefined, name: string) =>
   `${hostId || "local"}\t${name}`;
 
 /** The project a folder on a machine sits in (the deepest), or null. */
+// Only what matching reads, so a narrow query can feed it.
+export type ProjectFolder = Pick<
+  Project,
+  "id" | "host_id" | "working_directory" | "is_uncategorized"
+>;
+export type ManagedTmux = Pick<Session, "host_id" | "tmux_name">;
+
 export function projectMatcher(
-  projects: Project[]
+  projects: ProjectFolder[]
 ): (hostId: string, path: string) => string | null {
   const dirs = projects
     .filter((p) => !p.is_uncategorized)
@@ -49,8 +56,8 @@ export function projectMatcher(
 
 export function discoverSessions(
   tmuxSessions: TmuxSessionInfo[],
-  projects: Project[],
-  managed: Session[]
+  projects: ProjectFolder[],
+  managed: ManagedTmux[]
 ): DiscoveredSession[] {
   // By machine and name: a session here doesn't hide one elsewhere.
   const managedNames = new Set(

package/lib/pr-generation.ts

@@ -1,4 +1,5 @@
-import { execFileSync } from "child_process";
+import { execFile } from "child_process";
+import { run } from "./tasks/gh";
 import { UNTRUSTED_RULE, untrusted } from "./orchestrator/untrusted";
 
 export interface GeneratedPRContent {
@@ -15,7 +16,7 @@ export async function generatePRContent(
 ): Promise<GeneratedPRContent> {
   try {
     // Get git context
-    const { diff, commits, changedFiles } = getGitContext(
+    const { diff, commits, changedFiles } = await getGitContext(
       workingDir,
       baseBranch
     );
@@ -45,23 +46,17 @@ export async function generatePRContent(
 /**
  * Get git context for PR generation
  */
-function getGitContext(
+async function getGitContext(
   workingDir: string,
   baseBranch: string
-): { diff: string; commits: string[]; changedFiles: string[] } {
+): Promise<{ diff: string; commits: string[]; changedFiles: string[] }> {
   let diff = "";
   let commits: string[] = [];
   let changedFiles: string[] = [];
 
   // Names and text here come from the repository; every one is an
   // argument to git, never shell text or an option.
-  const git = (args: string[]) =>
-    execFileSync("git", args, {
-      cwd: workingDir,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"],
-      maxBuffer: 10 * 1024 * 1024,
-    });
+  const git = (args: string[]) => run("git", args, workingDir, 10_000);
   const lines = (out: string) =>
     out
       .split("\n")
@@ -72,7 +67,7 @@ function getGitContext(
     // Try to get the remote base branch reference
     let baseBranchRef = baseBranch;
     try {
-      git([
+      await git([
         "rev-parse",
         "--verify",
         "--end-of-options",
@@ -82,7 +77,7 @@ function getGitContext(
     } catch {
       // Fall back to local branch
       try {
-        git(["rev-parse", "--verify", "--end-of-options", baseBranch]);
+        await git(["rev-parse", "--verify", "--end-of-options", baseBranch]);
       } catch {
         // Base branch doesn't exist
         return { diff, commits, changedFiles };
@@ -91,18 +86,18 @@ function getGitContext(
     const range = `${baseBranchRef}...HEAD`;
 
     try {
-      diff = git(["diff", "--stat", "--end-of-options", range, "--"]);
+      diff = await git(["diff", "--stat", "--end-of-options", range, "--"]);
     } catch {}
 
     try {
       changedFiles = lines(
-        git(["diff", "--name-only", "--end-of-options", range, "--"])
+        await git(["diff", "--name-only", "--end-of-options", range, "--"])
       );
     } catch {}
 
     try {
       commits = lines(
-        git([
+        await git([
           "log",
           "--pretty=format:%s",
           "--end-of-options",
@@ -114,11 +109,11 @@ function getGitContext(
 
     // Also include uncommitted changes
     try {
-      const workingDiff = git(["diff", "--stat"]);
+      const workingDiff = await git(["diff", "--stat"]);
       if (workingDiff) {
         diff = diff ? `${diff}\n${workingDiff}` : workingDiff;
       }
-      const uncommittedFiles = lines(git(["diff", "--name-only"]));
+      const uncommittedFiles = lines(await git(["diff", "--name-only"]));
       changedFiles = [...new Set([...changedFiles, ...uncommittedFiles])];
     } catch {}
   } catch (error) {
@@ -138,7 +133,7 @@ async function generateWithClaude(
 ): Promise<GeneratedPRContent | null> {
   // Check if Claude CLI is available
   try {
-    execFileSync("claude", ["--version"], { stdio: "pipe", timeout: 5000 });
+    await run("claude", ["--version"], workingDir, 5000);
   } catch {
     return null;
   }
@@ -148,14 +143,7 @@ async function generateWithClaude(
   try {
     // Use claude CLI with --print flag for non-interactive output
     // The prompt goes on stdin: never argv, never a shell.
-    const output = execFileSync("claude", ["--print"], {
-      cwd: workingDir,
-      input: prompt,
-      encoding: "utf-8",
-      timeout: 30000,
-      maxBuffer: 1024 * 1024,
-    });
-
+    const output = await claudePrint(workingDir, prompt);
     return parseClaudeResponse(output);
   } catch (error) {
     console.debug("Claude CLI invocation failed", error);
@@ -163,6 +151,28 @@ async function generateWithClaude(
   }
 }
 
+// `claude --print` with the prompt on stdin, off the event loop and killed
+// at the ceiling.
+function claudePrint(cwd: string, prompt: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      "claude",
+      ["--print"],
+      {
+        cwd,
+        encoding: "utf-8",
+        timeout: 30_000,
+        killSignal: "SIGKILL",
+        maxBuffer: 1024 * 1024,
+      },
+      (error, stdout) => (error ? reject(error) : resolve(stdout))
+    );
+    // claude exiting before it read the prompt is its failure, not a crash.
+    child.stdin?.on("error", () => {});
+    child.stdin?.end(prompt);
+  });
+}
+
 /**
  * Build prompt for PR generation
  */

package/lib/pr.ts

@@ -1,4 +1,6 @@
 import { execFileSync } from "child_process";
+import { run } from "./tasks/gh";
+import { GhBackoffError, isRateLimit } from "./tasks/gh-limit";
 
 /** The remote's default branch, or "main" when it has none. */
 export function remoteDefaultBranch(workingDir: string): string {
@@ -32,14 +34,19 @@ export interface CommitInfo {
   body: string;
 }
 
+// Every call here waits on git, gh or the network: all of it runs off the
+// event loop, so a slow GitHub never stalls the server's other requests.
+
 /**
- * Check if gh CLI is installed and authenticated
+ * Check if gh CLI is installed and authenticated. Throws GhBackoffError while
+ * every gh call waits out GitHub's rate limit: that isn't a missing login.
  */
-export function checkGhCli(): boolean {
+export async function checkGhCli(): Promise<boolean> {
   try {
-    execFileSync("gh", ["auth", "status"], { timeout: 5000, stdio: "pipe" });
+    await run("gh", ["auth", "status"], process.cwd(), 5000);
     return true;
-  } catch {
+  } catch (error) {
+    if (error instanceof GhBackoffError) throw error;
     return false;
   }
 }
@@ -47,22 +54,25 @@ export function checkGhCli(): boolean {
 /**
  * Get commits between current branch and base branch
  */
-export function getCommitsSinceBase(
+export async function getCommitsSinceBase(
   workingDir: string,
   baseBranch = "main"
-): CommitInfo[] {
+): Promise<CommitInfo[]> {
   try {
     // Get the merge base
     // Names come from the repository (its remote's default branch): they
     // are arguments, never shell text or options.
-    const mergeBase = execFileSync(
-      "git",
-      ["merge-base", "--end-of-options", baseBranch, "HEAD"],
-      { cwd: workingDir, encoding: "utf-8" }
+    const mergeBase = (
+      await run(
+        "git",
+        ["merge-base", "--end-of-options", baseBranch, "HEAD"],
+        workingDir,
+        10_000
+      )
     ).trim();
 
     // Get commits since merge base
-    const output = execFileSync(
+    const output = await run(
       "git",
       [
         "log",
@@ -70,7 +80,8 @@ export function getCommitsSinceBase(
         "--format=COMMIT_START%n%H%n%s%n%b%nCOMMIT_END",
         "--",
       ],
-      { cwd: workingDir, encoding: "utf-8" }
+      workingDir,
+      10_000
     );
 
     const commits: CommitInfo[] = [];
@@ -160,12 +171,12 @@ export function generatePRBody(commits: CommitInfo[]): string {
 /**
  * Get PR for a branch
  */
-export function getPRForBranch(
+export async function getPRForBranch(
   workingDir: string,
   branchName: string
-): PRInfo | null {
+): Promise<PRInfo | null> {
   try {
-    const output = execFileSync(
+    const output = await run(
       "gh",
       [
         "pr",
@@ -177,11 +188,16 @@ export function getPRForBranch(
         "--limit",
         "1",
       ],
-      { cwd: workingDir, encoding: "utf-8", timeout: 10000 }
+      workingDir,
+      10_000
     );
     const prs = JSON.parse(output);
     return prs.length > 0 ? prs[0] : null;
-  } catch {
+  } catch (error) {
+    // GitHub's rate limit says nothing about whether a PR exists.
+    if (error instanceof GhBackoffError) throw error;
+    if (isRateLimit(error))
+      throw new GhBackoffError("GitHub's rate limit is spent; try again later");
     return null;
   }
 }
@@ -189,30 +205,32 @@ export function getPRForBranch(
 /**
  * Create a new PR
  */
-export function createPR(
+export async function createPR(
   workingDir: string,
   branchName: string,
   baseBranch: string,
   title: string,
   body: string
-): PRInfo {
+): Promise<PRInfo> {
   // First ensure branch is pushed
   try {
-    execFileSync("git", ["push", "-u", "origin", "--", branchName], {
-      cwd: workingDir,
-      timeout: 30000,
-      stdio: "pipe",
-    });
+    await run(
+      "git",
+      ["push", "-u", "origin", "--", branchName],
+      workingDir,
+      30_000
+    );
   } catch {
     // Branch might already be pushed
   }
 
   // Create PR using gh CLI
   // gh pr create outputs the PR URL on success
-  const output = execFileSync(
+  const output = await run(
     "gh",
     ["pr", "create", "--title", title, "--base", baseBranch, "--body", body],
-    { cwd: workingDir, encoding: "utf-8", timeout: 30000 }
+    workingDir,
+    30_000
   );
 
   // Parse URL from output (gh pr create prints the URL)
@@ -235,20 +253,24 @@ export function createPR(
 /**
  * Get current branch name
  */
-export function getCurrentBranch(workingDir: string): string {
-  return execFileSync("git", ["branch", "--show-current"], {
-    cwd: workingDir,
-    encoding: "utf-8",
-  }).trim();
+export async function getCurrentBranch(workingDir: string): Promise<string> {
+  return (
+    await run("git", ["branch", "--show-current"], workingDir, 10_000)
+  ).trim();
 }
 
 /**
- * Get the default base branch (main or master)
+ * Get the default base branch: the remote's, or "main" when it has none.
  */
-export function getBaseBranch(workingDir: string): string {
+export async function getBaseBranch(workingDir: string): Promise<string> {
   try {
-    // Try to get from remote HEAD
-    return remoteDefaultBranch(workingDir);
+    const ref = await run(
+      "git",
+      ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+      workingDir,
+      10_000
+    );
+    return ref.trim().replace(/^origin\//, "");
   } catch {
     return "main";
   }

package/lib/status-detector.ts

@@ -662,6 +662,13 @@ class SessionStatusDetector {
     return [...this.cache.data.values()];
   }
 
+  // A new object whenever the listing or its errors change (the cache is
+  // replaced, never edited): readers derived from them can skip the work
+  // while it's the same one.
+  listingStamp(): object {
+    return this.cache;
+  }
+
   hostErrors(): Record<string, string> {
     return Object.fromEntries(this.cache.hostErrors);
   }

package/package.json

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