@saadnvd1/agent-os 0.3.588 → 0.3.592

package/lib/orchestrator/held-asks.ts

@@ -0,0 +1,117 @@
+// A gate that failed twice holds the task at once, but Saad's ask waits
+// until the task's agent is done: idle, nothing sent to it lately, and CI
+// settled on its latest head. Then the ask goes up at that head, the commit
+// he'd merge; if the head moves after that, followAskHeads moves the same ask.
+
+import { db, type Session } from "../db";
+import { prFor } from "../tasks/session";
+import { latestApproval } from "./ask-approvals";
+import { askSaadAbout } from "./escalate";
+import { getCheck } from "./checks";
+import { openBySubject, workSubject } from "./asks";
+import { recentlyMessaged } from "./conditions";
+import type { SessionFacts } from "./facts";
+import {
+  failedTwiceWhy,
+  heldAskFailures,
+  releaseHeldAsks,
+  type FailureRow,
+} from "./gates";
+import { getOrchestrator } from "./home";
+import { commitTime, fetchRefs, repoOf } from "./repo";
+import { ciSettleIn, SETTLE_S } from "./task-state";
+
+// Long enough for the orchestrator to send the findings that caused the
+// escalation; the hour is the most a stuck agent can hide an escalation.
+export const HOLD_MIN_MS = SETTLE_S * 1000;
+export const HOLD_MAX_MS = 60 * 60 * 1000;
+
+const short = (sha: string) => sha.slice(0, 7);
+const sqliteMs = (t: string) => Date.parse(`${t.replace(" ", "T")}Z`);
+
+export async function raiseHeldAsks(
+  workspaceId: string,
+  facts: SessionFacts[],
+  now = Date.now()
+): Promise<void> {
+  const byTask = new Map<string, FailureRow[]>();
+  for (const row of heldAskFailures(workspaceId))
+    byTask.set(row.session_id, [...(byTask.get(row.session_id) ?? []), row]);
+  if (!byTask.size) return;
+  const orch = getOrchestrator(workspaceId);
+  const messaged = orch ? recentlyMessaged(orch.id, now) : new Set<string>();
+  for (const [taskId, rows] of byTask) {
+    try {
+      await raiseFor(workspaceId, taskId, rows, facts, messaged, now);
+    } catch (error) {
+      console.error(`Raising ${taskId}'s held ask:`, error);
+    }
+  }
+}
+
+async function raiseFor(
+  workspaceId: string,
+  taskId: string,
+  rows: FailureRow[],
+  facts: SessionFacts[],
+  messaged: Set<string>,
+  now: number
+): Promise<void> {
+  const f = facts.find((x) => x.id === taskId);
+  const task = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(taskId) as
+    | Session
+    | undefined;
+  // Gone, merged or dropped: nothing left to ask. An open ask or an
+  // unspent approval already covers it (followAskHeads, heldVerdict).
+  if (
+    !task ||
+    task.task_status !== "running" ||
+    openBySubject(workspaceId, workSubject(taskId)) ||
+    latestApproval(workspaceId, workSubject(taskId))
+  )
+    return releaseHeldAsks(taskId);
+  const heldFor =
+    now - Math.min(...rows.map((r) => sqliteMs(r.ask_held_at as string)));
+  const overdue = heldFor >= HOLD_MAX_MS;
+  // No facts yet is a wait, but never past the hour.
+  if (!f && !overdue) return;
+  // A gh failure throws and keeps the hold: only GitHub saying the PR isn't
+  // open releases it.
+  const pr = await prFor(task, true, true);
+  if (pr?.state !== "OPEN" || !pr.head) return releaseHeldAsks(taskId);
+  if (!overdue && f) {
+    if (f.status === "running" || f.compacting) return;
+    if (messaged.has(taskId) || heldFor < HOLD_MIN_MS) return;
+    if (getCheck(taskId, pr.head, "review")?.status === "running") return;
+    const repo = repoOf(task);
+    // The head may be a commit this clone hasn't fetched yet.
+    await fetchRefs(repo, task);
+    const committedAt = await commitTime(repo, pr.head);
+    if (pr.checks === "pending") return;
+    if (pr.checks === "pass") {
+      const left = ciSettleIn({
+        workspaceId,
+        taskId,
+        sha: pr.head,
+        checkCount: pr.checkCount ?? 0,
+        committedAt,
+        now,
+      });
+      if (left > 0) return;
+    } else if (now / 1000 - committedAt < SETTLE_S) return;
+  }
+  const last = rows.find((r) => r.last_sha)?.last_sha;
+  const why = [
+    ...rows.map((r) => failedTwiceWhy(r.gate, r.last_reason ?? "")),
+    ...(last && last !== pr.head
+      ? [
+          `Asked at ${short(pr.head)}, its head after the fixes since ${short(last)}.`,
+        ]
+      : []),
+    ...(overdue
+      ? [`${task.name} was still working after an hour; this is its head now.`]
+      : []),
+  ].join("\n");
+  askSaadAbout(workspaceId, task, why, pr.url, pr.head);
+  releaseHeldAsks(taskId);
+}

package/lib/orchestrator/held.ts

@@ -40,9 +40,12 @@ export function heldVerdict(
       text: `${task.name}: ${why}. Asked him again; don't retry.`,
     };
   }
+  const waiting = held.some((h) => h.ask_held_at)
+    ? " His ask goes up once its agent is idle and CI has settled on its latest head."
+    : "";
   return {
     ok: false,
     wait: false,
-    text: `${task.name} is with Saad (${held.map((h) => h.gate).join(", ")}: ${held[0].last_reason}). Only he can merge it now, or approve it on his asks list.`,
+    text: `${task.name} is with Saad (${held.map((h) => h.gate).join(", ")}: ${held[0].last_reason}). Only he can merge it now, or approve it on his asks list.${waiting}`,
   };
 }

package/lib/orchestrator/home.ts

@@ -12,10 +12,13 @@ import path from "path";
 import { randomBytes, randomUUID, timingSafeEqual } from "crypto";
 import { db, type Session } from "../db";
 import { getWorkspace } from "../workspaces";
+import { refuseRealStateUnderTest } from "../test-home-guard";
 
 // It works through tools, not in a repo: a scratch folder of its own.
 export const orchestratorDir = (workspaceId: string) =>
-  path.join(os.homedir(), ".agent-os", "orchestrators", workspaceId);
+  refuseRealStateUnderTest(
+    path.join(os.homedir(), ".agent-os", "orchestrators", workspaceId)
+  );
 
 export function getOrchestrator(workspaceId: string): Session | null {
   return (

package/lib/orchestrator/watcher.ts

@@ -17,6 +17,7 @@ import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
 import { followAskHeads } from "./ask-heads";
+import { raiseHeldAsks } from "./held-asks";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
 import { awayTick } from "../away/run";
@@ -79,6 +80,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
     await followAskHeads(workspaceId, facts).catch((error) =>
       console.error(`Following ask heads in ${workspaceId}:`, error)
     );
+    await raiseHeldAsks(workspaceId, facts).catch((error) =>
+      console.error(`Raising held asks in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()

package/lib/tasks/held-remote.ts

@@ -113,11 +113,10 @@ export async function flushUndelivered(
       ).run(m.id);
       continue;
     }
-    const line = wakeLine({
-      fromName: m.from_name,
-      fromId: m.from_id,
-      body: m.body,
-    });
+    const line = wakeLine(
+      { fromName: m.from_name, fromId: m.from_id, body: m.body },
+      { inline: true }
+    );
     const res = await relayToHeldTask(task, line, m.from_name, m.id, false);
     if (res.state === "failed") return;
     db.prepare(

package/lib/test-home-guard.ts

@@ -0,0 +1,23 @@
+import os from "os";
+import path from "path";
+
+// Under the test runner, refuse a path inside the real ~/.agent-os: a test
+// that resolves there would leave folders in the owner's state. The real
+// home comes from the account, not $HOME, which the test setup replaces.
+export function refuseRealStateUnderTest(p: string): string {
+  if (!process.env.VITEST) return p;
+  let real: string;
+  try {
+    real = os.userInfo().homedir;
+  } catch {
+    return p;
+  }
+  const state = path.join(real, ".agent-os");
+  const resolved = path.resolve(p);
+  if (resolved === state || resolved.startsWith(state + path.sep)) {
+    throw new Error(
+      `Refusing to use ${state} under the test runner (${resolved}): point HOME at a temp folder`
+    );
+  }
+  return p;
+}

package/lib/worktrees.ts

@@ -12,6 +12,7 @@ import {
   slugify,
   generateBranchName,
 } from "./git";
+import { refuseRealStateUnderTest } from "./test-home-guard";
 import { installWorktreeHooks } from "./worktree-hooks";
 import { gitResult, isGitError, worktreeList } from "./git-exec";
 import { addWorktree } from "./worktree-add";
@@ -43,8 +44,13 @@ export async function mainCheckoutOf(worktreePath: string): Promise<string> {
   }
 }
 
+/** Where task worktrees live: ~/.agent-os/worktrees. */
+export function worktreesRoot(home = os.homedir()): string {
+  return refuseRealStateUnderTest(path.join(home, ".agent-os", "worktrees"));
+}
+
 // Base directory for all worktrees
-export const WORKTREES_DIR = path.join(os.homedir(), ".agent-os", "worktrees");
+export const WORKTREES_DIR = worktreesRoot();
 
 export interface WorktreeInfo {
   worktreePath: string;

package/package.json

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