@saadnvd1/agent-os 0.3.461 → 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.
@@ -1262,8 +1266,16 @@ descriptors, child processes and spawns per minute; `scripts/perf/execs.mjs
 spawns with eslogger (macOS) or strace (Linux) and need passwordless sudo for
 that one number. Run them on a machine with room to spare.
 
-A pre-commit hook formats and lints staged files, then typechecks and runs the
-tests. CI runs `scripts/check --build` on every pull request and push to main,
+A pre-commit hook (`.husky/pre-commit`, installed by `npm install`) checks
+only what is staged, in well under two seconds: `prettier --check`, failing
+with the `npx prettier --write …` command that fixes it, and a scan of the
+added lines for token-shaped secrets with the merge gate's own rule
+(`scripts/hooks/staged-secrets.ts` reads `secretsIn` from
+`lib/orchestrator/diff.ts`), naming the file and line. Build a test's fake
+token at runtime (`"gh" + "p_" + "a".repeat(36)`) rather than writing it
+whole. It runs in the worktrees AgentOS makes too, which have no `.husky/_`
+until `npm install` runs in them. Typecheck, lint and tests are left to CI.
+In an emergency, `git commit --no-verify` skips it. CI runs `scripts/check --build` on every pull request and push to main,
 which also holds the app's first-load JavaScript to a budget
 (`scripts/check-bundle.mjs`; `npx next experimental-analyze` shows what's in
 it), and fails a pull request whose body has no Code review section for its head

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/lib/worktree-hooks.ts

@@ -85,10 +85,19 @@ async function ownHooks(worktree: string): Promise<string> {
   return sh(path.join(common, "hooks"));
 }
 
+// Husky writes `.husky/_` on `npm install`, and it's gitignored, so a new
+// worktree has none and its hooks would silently not run: run the hook
+// script from `.husky/` the way husky's own runner does.
 const delegate = (own: string, hook: string) =>
   `root="$(git rev-parse --show-toplevel)"
 own=${own}/${hook}
 [ -x "$own" ] && exec "$own" "$@"
+case "$own" in
+*/.husky/_/${hook})
+  script="\${own%/_/${hook}}/${hook}"
+  [ -f "$script" ] && [ "\${HUSKY-}" != 0 ] && PATH="node_modules/.bin:$PATH" exec sh -e "$script" "$@"
+  ;;
+esac
 exit 0
 `;
 

package/package.json

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

package/scripts/hooks/staged-secrets.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { execFileSync, spawnSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { scanDiff } from "./staged-secrets";
+
+// Fakes are built here, never written whole: a literal would be the very
+// thing this scan (and the merge gate) refuses.
+const fake = {
+  github: ["gh", "p_", "a1B2".repeat(9)].join(""),
+  anthropic: ["sk", "-ant-", "x9Y8".repeat(8)].join(""),
+  aws: ["AK", "IA", "Q7".repeat(8)].join(""),
+};
+
+const diffOf = (file: string, start: number, lines: string[]) =>
+  [
+    `diff --git a/${file} b/${file}`,
+    "index 0000000..1111111 100644",
+    `--- a/${file}`,
+    `+++ b/${file}`,
+    `@@ -0,0 +${start},${lines.length} @@`,
+    ...lines.map((l) => `+${l}`),
+  ].join("\n");
+
+describe("scanDiff", () => {
+  it("names the file and line of each token-shaped string", () => {
+    const diff = [
+      diffOf("lib/a.ts", 10, ["const ok = 1;", `const t = "${fake.github}";`]),
+      diffOf("docs/b.md", 3, [`key: ${fake.anthropic}`, "", fake.aws]),
+    ].join("\n");
+    expect(scanDiff(diff)).toEqual([
+      { file: "lib/a.ts", line: 11, what: expect.stringMatching(/^ghp_/) },
+      { file: "docs/b.md", line: 3, what: expect.stringMatching(/^sk-/) },
+      { file: "docs/b.md", line: 5, what: expect.stringMatching(/^AKIA/) },
+    ]);
+  });
+
+  it("flags an env-style assignment of a real-looking value, not a placeholder", () => {
+    const diff = diffOf(".env.example", 1, [
+      `API_TOKEN=${"q7R".repeat(6)}42`,
+      "API_KEY=${API_KEY}",
+      "SECRET_KEY=changeme",
+    ]);
+    expect(scanDiff(diff)).toEqual([
+      { file: ".env.example", line: 1, what: "API_TOKEN = …" },
+    ]);
+  });
+
+  it("passes code that builds a fake at runtime", () => {
+    const diff = diffOf("lib/c.test.ts", 1, [
+      'const t = ["gh", "p_", "a".repeat(36)].join("");',
+    ]);
+    expect(scanDiff(diff)).toEqual([]);
+  });
+
+  it("doesn't take an added line starting with ++ for a file header", () => {
+    const diff = diffOf("lib/d.ts", 1, [`++ ${fake.github}`]);
+    expect(scanDiff(diff)).toEqual([
+      { file: "lib/d.ts", line: 1, what: expect.stringMatching(/^ghp_/) },
+    ]);
+  });
+
+  it("fails the commit on a staged secret, and passes once it's gone", () => {
+    const repo = fs.mkdtempSync(path.join(os.tmpdir(), "staged-secrets-"));
+    const git = (...args: string[]) =>
+      execFileSync("git", args, { cwd: repo, stdio: "pipe" });
+    const scan = () =>
+      spawnSync(
+        path.resolve("node_modules/.bin/tsx"),
+        [path.resolve("scripts/hooks/staged-secrets.ts")],
+        { cwd: repo, encoding: "utf-8" }
+      );
+    try {
+      git("init", "-q");
+      fs.writeFileSync(
+        path.join(repo, "x.ts"),
+        `const t = "${fake.github}";\n`
+      );
+      git("add", "x.ts");
+      const bad = scan();
+      expect(bad.status).toBe(1);
+      expect(bad.stderr).toContain("x.ts:1");
+      expect(bad.stderr).toContain("at runtime");
+      fs.writeFileSync(path.join(repo, "x.ts"), "const t = process.env.T;\n");
+      git("add", "x.ts");
+      expect(scan().status).toBe(0);
+    } finally {
+      fs.rmSync(repo, { recursive: true, force: true });
+    }
+  });
+});

package/scripts/hooks/staged-secrets.ts

@@ -0,0 +1,64 @@
+/**
+ * The pre-commit secret scan: the staged diff's added lines, read with the
+ * merge gate's own rule (lib/orchestrator/diff.ts secretsIn), so a commit
+ * that would fail the gate fails here first, naming the file and line.
+ */
+
+import { execFileSync } from "child_process";
+import { secretsIn } from "../../lib/orchestrator/diff";
+
+export interface SecretHit {
+  file: string;
+  line: number;
+  what: string;
+}
+
+// Each added line of a `git diff -U0` with the file and new line number it
+// lands on. Headers are only read before a file's first hunk, so an added
+// line that itself starts with "++" isn't taken for one.
+export function scanDiff(diff: string): SecretHit[] {
+  const hits: SecretHit[] = [];
+  let file = "";
+  let line = 0;
+  let header = false;
+  for (const l of diff.split("\n")) {
+    if (l.startsWith("diff --git ")) {
+      header = true;
+    } else if (header && l.startsWith("+++ ")) {
+      file = l.slice(4).replace(/^b\//, "");
+    } else if (l.startsWith("@@")) {
+      header = false;
+      line = Number(l.match(/\+(\d+)/)?.[1] ?? 0);
+    } else if (!header && l.startsWith("+")) {
+      const what = secretsIn(l.slice(1));
+      if (what) hits.push({ file, line, what });
+      line++;
+    }
+  }
+  return hits;
+}
+
+if (process.argv[1]?.endsWith("staged-secrets.ts")) {
+  const diff = execFileSync(
+    "git",
+    [
+      "diff",
+      "--cached",
+      "-U0",
+      "--no-color",
+      "--no-ext-diff",
+      "--diff-filter=ACMR",
+    ],
+    { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 }
+  );
+  const hits = scanDiff(diff);
+  for (const h of hits)
+    console.error(`✗ ${h.file}:${h.line}: looks like a secret (${h.what})`);
+  if (hits.length) {
+    console.error(
+      "The merge gate refuses token-shaped strings. For a test fixture, build the fake at runtime\n" +
+        '(e.g. "gh" + "p_" + "a".repeat(36)) instead of writing it as a literal.'
+    );
+    process.exit(1);
+  }
+}