@saadnvd1/agent-os 0.3.637 → 0.3.644

package/lib/orchestrator/signoff.test-helpers.ts

@@ -0,0 +1,322 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execFileSync } from "child_process";
+import { beforeAll, beforeEach, expect, vi } from "vitest";
+import type { TaskPR } from "@/lib/tasks/state";
+import type { ClaudeRun } from "./claude-cli";
+import type { SessionFacts } from "./facts";
+
+// Shared fixtures for the signoff*.test.ts files: a real repository with a
+// local bare remote, gh faked around it. Import this before anything it mocks.
+// Tests change the fake world through S.
+export const S: {
+  pr: TaskPR | null;
+  prError: Error | null;
+  pane: string;
+  refuseMerge: string | null;
+  probeOut: string | Error;
+  ciLog: string;
+  commitDate: string | undefined;
+} = {
+  pr: null,
+  prError: null,
+  pane: "",
+  refuseMerge: null,
+  probeOut: "0",
+  ciLog:
+    "Test 1\tRun tests\t2026-01-01T00:00:00.0Z  FAIL  src/a.test.ts > adds\n",
+  commitDate: "2026-01-01T00:00:00Z",
+};
+export const ATTRIBUTED = "a Co-Authored-By trailer naming Claude" as const;
+export const merges: string[][] = [];
+export const JOB_URL = "https://github.com/o/r/actions/runs/1/job/2";
+// CI failing on the head, with a log the loop guard can read.
+export const failingCI = (failing = "unit") =>
+  ({ ...S.pr!, checks: "fail", failing, failingUrl: JOB_URL }) as TaskPR;
+export const isProbe = (args: string[]) =>
+  args[0] === "api" ||
+  (args[0] === "pr" &&
+    args[1] === "list" &&
+    args.includes("statusCheckRollup"));
+
+vi.mock("@/lib/tasks/gh", async (importOriginal) => {
+  const real = await importOriginal<typeof import("@/lib/tasks/gh")>();
+  return {
+    ...real,
+    run: async (cmd: string, args: string[], cwd: string, t?: number) => {
+      if (cmd === "gh" && args[0] === "run" && args[1] === "view")
+        return S.ciLog;
+      if (cmd === "gh" && isProbe(args)) {
+        if (S.probeOut instanceof Error) throw S.probeOut;
+        return S.probeOut;
+      }
+      if (cmd === "gh") {
+        if (S.refuseMerge) throw new Error(S.refuseMerge);
+        merges.push(args);
+        if (S.pr) S.pr = { ...S.pr, state: "MERGED" };
+        return "";
+      }
+      if (cmd === "tmux") throw new Error("no tmux in tests");
+      return real.run(cmd, args, cwd, t);
+    },
+    findPR: async () => S.pr,
+    findPRStrict: async () => {
+      if (S.prError) throw S.prError;
+      return S.pr;
+    },
+  };
+});
+// The test clones have a local origin; the CI probes need a GitHub name.
+vi.mock("./repo-slug", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./repo-slug")>()),
+  repoSlug: async () => "o/r",
+}));
+vi.mock("@/lib/status-detector", () => ({
+  checkWaitingPatterns: (t: string) => /Allow\?/.test(t),
+  statusDetector: {
+    refreshCache: async () => {},
+    sessionExists: () => S.pane !== "",
+    getStatus: async () => "idle",
+    titleFor: () => "",
+    getTimestamp: () => 0,
+    hostFor: () => "local",
+    capturePane: async () => S.pane,
+  },
+}));
+
+export const { db, stackQueries, updateSessionRow } = await import("@/lib/db");
+export const { createProject } = await import("@/lib/projects");
+export const { createWorkspace, setProjectWorkspace } =
+  await import("@/lib/workspaces");
+export const { ensureOrchestrator } = await import("./home");
+export const { runTool } = await import("./serve");
+export const { judge, landDeps, mergeJudged, refundIfRefused } =
+  await import("./signoff");
+export const { armTask, mergeArmed } = await import("./armed");
+export const { resumeReviews, review } = await import("./review");
+export const { getCheck, putCheck } = await import("./checks");
+export const { failureOf, recordFailure } = await import("./gates");
+export const { LOOP_GUARD_COMMITS } = await import("./loop-guard");
+export const { clearRepoCI } = await import("./repo-ci");
+export const { listNotes } = await import("./notes");
+export const { listItems } = await import("@/lib/chat/store");
+export const { claudeArgs } = await import("./claude-cli");
+export const { seedSession } = await import("./testing");
+export const { answerAsk, getAsk, openAsks, raiseAsk, BRAKE_SUBJECT } =
+  await import("./asks");
+export const { setMergeApprovals } = await import("./merge-approvals");
+export const { releaseInterruptedClaims, spendApproval } =
+  await import("./ask-approvals");
+export const { amendBrief } = await import("./amendments");
+export const { fetchRefs } = await import("./repo");
+export const { getTaskSession } = await import("@/lib/tasks/session");
+export const { changedFiles } = await import("./diff");
+export const { followAskHeads } = await import("./ask-heads");
+export const { followAskVerdicts } = await import("./ask-verdict");
+export const { raiseHeldAsks, HOLD_MIN_MS, HOLD_MAX_MS } =
+  await import("./held-asks");
+
+// The one ask a task's escalation leaves on Saad's list.
+export function oneGateAsk(w: string, task: string, sha: string) {
+  const asks = openAsks(w);
+  expect(asks).toHaveLength(1);
+  expect(asks[0]).toMatchObject({
+    subject: `task:${task}`,
+    kind: "gate",
+    title: "Merge add-a?",
+    link: "https://github.com/o/r/pull/7",
+    sha,
+  });
+  return asks[0];
+}
+
+// The loop guard's last strike: the gate already failed on the commits
+// before this one.
+export const failedBefore = (w: string, task: string, gate: string) => {
+  for (let i = 1; i < LOOP_GUARD_COMMITS; i++)
+    recordFailure(w, task, gate, `earlier ${i}`, String(i).repeat(40));
+};
+
+// Facts for the task: its agent idle, or busy.
+export const taskFacts = (task: string, status: "idle" | "running" = "idle") =>
+  [
+    { id: task, name: "add-a", status, task: { state: "review", pr: S.pr } },
+  ] as unknown as SessionFacts[];
+
+// A failed-twice escalation's ask goes up once the agent is idle and CI
+// has settled; `after` ms from now.
+// The first look at a head's checks starts CI's settle clock, so it looks
+// twice, the second a settle period later.
+export const askUp = async (
+  w: string,
+  task: string,
+  after = HOLD_MIN_MS + 1000,
+  status: "idle" | "running" = "idle"
+) => {
+  await raiseHeldAsks(w, taskFacts(task, status), Date.now() + after);
+  await raiseHeldAsks(w, taskFacts(task, status), Date.now() + after + 200_000);
+};
+
+// Poll for the condition, generously: a loaded machine is slow, not wrong.
+export const POLL = { timeout: 20000, interval: 20 };
+
+beforeAll(() => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "aos-orch-signoff-"));
+  vi.spyOn(os, "homedir").mockReturnValue(home);
+});
+beforeEach(() => {
+  merges.length = 0;
+  S.refuseMerge = null;
+  S.probeOut = "0";
+  S.ciLog =
+    "Test 1\tRun tests\t2026-01-01T00:00:00.0Z  FAIL  src/a.test.ts > adds\n";
+  clearRepoCI();
+  // A live terminal at its prompt, nothing waiting.
+  S.pane = "❯ ";
+});
+
+export const git = (cwd: string, ...args: string[]) =>
+  execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: "pipe",
+    env: {
+      ...process.env,
+      ...(S.commitDate ? { GIT_COMMITTER_DATE: S.commitDate } : {}),
+    },
+  }).trim();
+
+export function commit(
+  repo: string,
+  file: string,
+  text: string,
+  link?: string
+): string {
+  fs.mkdirSync(path.dirname(path.join(repo, file)), { recursive: true });
+  if (link) fs.symlinkSync(link, path.join(repo, file));
+  else fs.writeFileSync(path.join(repo, file), text);
+  git(repo, "add", "-A");
+  git(repo, "commit", "-qm", `change ${file}`);
+  git(repo, "push", "-q", "origin", "HEAD");
+  return git(repo, "rev-parse", "HEAD");
+}
+
+// A workspace whose project is a real clone, with a task on its branch
+// and its PR open at the branch's head.
+export function setup(
+  opts: {
+    card?: boolean;
+    onMain?: Array<[string, string]>;
+    approvals?: boolean;
+  } = {}
+) {
+  setMergeApprovals(opts.approvals ?? false);
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-orch-repo-"));
+  const remote = path.join(root, "remote.git");
+  const repo = path.join(root, "repo");
+  git(root, "init", "-q", "--bare", "-b", "main", remote);
+  git(root, "clone", "-q", remote, repo);
+  git(repo, "config", "user.email", "t@example.com");
+  git(repo, "config", "user.name", "T");
+  commit(repo, "README.md", "hello\n");
+  for (const file of opts.onMain ?? []) commit(repo, ...file);
+  git(repo, "checkout", "-qb", "feature/t");
+  const sha = commit(repo, "src/a.ts", "export const a = 1;\n");
+
+  const workspace = createWorkspace(`ws-${path.basename(root)}`);
+  const project = createProject({
+    name: `app-${path.basename(root)}`,
+    workingDirectory: repo,
+  });
+  setProjectWorkspace(project.id, workspace.id);
+  ensureOrchestrator(workspace.id);
+  const task = seedSession({
+    projectId: project.id,
+    name: "add-a",
+    task: true,
+    branch: "feature/t",
+  });
+  updateSessionRow(db, task, {
+    base_branch: "main",
+    task_prompt: "Add a",
+    lh_card_id: opts.card ? "card-1" : null,
+    pr_number: 7,
+  });
+  S.pr = {
+    number: 7,
+    url: "https://github.com/o/r/pull/7",
+    state: "OPEN",
+    checks: "pass",
+    head: sha,
+    failing: null,
+    checkCount: 1,
+    attribution: null,
+  };
+  const w = workspace.id;
+  // CI has looked settled on every head for a while.
+  const settled = () =>
+    putCheck({
+      workspaceId: w,
+      sessionId: task,
+      sha: S.pr!.head!,
+      kind: "ci",
+      status: "pass",
+      detail: JSON.stringify({ count: S.pr!.checkCount, at: 0 }),
+    });
+  return {
+    w,
+    repo,
+    task,
+    sha,
+    signOff: (settle = true) => {
+      if (settle) settled();
+      return runTool(w, "sign_off", { task: "add-a" });
+    },
+    push: (file: string, text: string, link?: string) => {
+      const next = commit(repo, file, text, link);
+      S.pr = { ...S.pr!, head: next };
+      return next;
+    },
+  };
+}
+
+// A reviewer that answers without a model, and remembers how it was run.
+export function reviewer(verdict: "pass" | "block", within = true) {
+  const runs: ClaudeRun[] = [];
+  const claude = async (run: ClaudeRun) => {
+    runs.push(run);
+    if (!run.tools.length)
+      return {
+        within,
+        reason: within ? "matches the card" : "adds billing, not on the card",
+      };
+    return verdict === "pass"
+      ? { verdict, summary: "Looks right.", findings: [] }
+      : {
+          verdict,
+          summary: "One bug.",
+          findings: [
+            {
+              severity: "blocking",
+              file: "src/a.ts",
+              line: 1,
+              summary: "off by one",
+            },
+          ],
+        };
+  };
+  return { claude, runs };
+}
+
+export const reviewNow = (
+  w: string,
+  verdict: "pass" | "block" = "pass",
+  within = true
+) => {
+  const r = reviewer(verdict, within);
+  return review(w, "add-a", { wait: true, claude: r.claude }).then((text) => ({
+    text,
+    runs: r.runs,
+  }));
+};

package/lib/orchestrator/signoff.ts

@@ -4,8 +4,9 @@
  * anything touching CI config, build and hook scripts, agent config, deploys
  * or secrets handling goes to Saad whatever the gates say. A repository with
  * no CI (decided from the repository, never from one head with no checks)
- * and a gate failing on two different commits go to him either way. Once a
- * task is with Saad the orchestrator doesn't merge it; he signs it off or drops it.
+ * and a task the loop guard finds stuck (loop-guard.ts) go to him either
+ * way. Once a task is with Saad the orchestrator doesn't merge it; he signs
+ * it off or drops it.
  */
 
 import { MERGED_AS, type MergeMethod } from "../tasks/merge-policy";
@@ -28,9 +29,17 @@ import { countFailure, escalate } from "./escalate";
 import {
   ciGate,
   evaluateGates,
+  failureCounted,
   holdingEscalations,
+  recordPass,
   type GateInput,
+  type GateOutcome,
 } from "./gates";
+import {
+  readCiSignature,
+  reasonSignature,
+  reviewSignature,
+} from "./loop-guard";
 import { addNote } from "./notes";
 import { latestApproval, refundApproval, spendApproval } from "./ask-approvals";
 import { workSubject } from "./asks";
@@ -121,6 +130,7 @@ export async function judge(
     async () => ({
       checks: pr.checks,
       failing: pr.failing,
+      failingUrl: pr.failingUrl,
       settleIn: ciSettleIn({
         workspaceId,
         taskId: task.id,
@@ -257,17 +267,43 @@ export async function gateVerdict(
   const waiting = outcomes.filter((o) => o.state === "wait");
   if (!failed.length && !waiting.length)
     return { ok: true, sha, pr: pr.number };
-  const lines = [
-    ...failed.map((o) =>
-      opts.count === false
-        ? `- ${o.gate} failed: ${o.reason}`
-        : countFailure(workspaceId, work, o, pr.url, sha).line
-    ),
-    ...waiting.map((o) => `- ${o.gate}: not yet, ${o.reason}`),
-  ];
+  const lines: string[] = [];
+  if (opts.count === false)
+    lines.push(...failed.map((o) => `- ${o.gate} failed: ${o.reason}`));
+  else {
+    for (const o of outcomes)
+      if (o.state === "pass") recordPass(work.id, o.gate);
+    for (const o of failed) {
+      const signature = await failureSignature(work, o, live);
+      lines.push(
+        countFailure(workspaceId, work, o, pr.url, sha, { signature }).line
+      );
+    }
+  }
+  lines.push(...waiting.map((o) => `- ${o.gate}: not yet, ${o.reason}`));
   return no(`${head}\n${lines.join("\n")}`, !failed.length);
 }
 
+// What the loop guard compares between this failure and the one before.
+// The CI log is read once per head: a head already counted needs none.
+async function failureSignature(
+  work: GateWork,
+  o: GateOutcome,
+  i: Omit<GateInput, "sha" | "ruleBreaks">
+): Promise<string | null> {
+  if (o.gate === "review") return reviewSignature(i.review?.detail ?? null);
+  if (o.gate === "scope" && i.scope?.status === "block")
+    return reasonSignature(i.scope.detail);
+  if (o.gate !== "ci" || i.checks !== "fail") return reasonSignature(o.reason);
+  if (failureCounted(work.id, "ci", work.sha)) return null;
+  return readCiSignature({
+    repo: work.repo,
+    prUrl: work.pr.url,
+    failing: i.failing,
+    failingUrl: i.failingUrl,
+  });
+}
+
 // Asked only when it can change the answer: a head with no checks that
 // isn't settling or conflicting.
 async function repoCIFor(
@@ -331,7 +367,9 @@ export async function refundIfRefused(
     await merge();
   } catch (e) {
     const merged = db
-      .prepare(`SELECT 1 FROM sessions WHERE id = ? AND task_status = 'merged'`)
+      .prepare(
+        `SELECT 1 FROM session_rows WHERE id = ? AND task_status = 'merged'`
+      )
       .get(taskId);
     if (approval && !merged) refundApproval(approval);
     throw e;

package/lib/orchestrator/targets.ts

@@ -56,7 +56,7 @@ export function workspaceTask(
   if (pr !== null) {
     const rows = db
       .prepare(
-        `SELECT s.*, p.name AS project_name FROM sessions s
+        `SELECT s.*, p.name AS project_name FROM session_rows s
          JOIN projects p ON p.id = s.project_id
          WHERE p.workspace_id = ? AND s.pr_number = ? AND s.task_status IS NOT NULL
          ORDER BY s.created_at DESC`

package/lib/orchestrator/task-state.ts

@@ -9,8 +9,8 @@ import { blockedReason } from "../tasks/state";
 import { checkWaitingPatterns, statusDetector } from "../status-detector";
 import { getCheck, putCheck } from "./checks";
 import { cleanRemoteText, hostLink, type HostLink } from "../hosts/remote-api";
-import { heldChatFacts, isHeldRemote } from "../tasks/held-remote";
-import { hostTasks } from "../tasks/remote";
+import { heldChatFacts, isHeldRemote } from "../tasks/contract/held-calls";
+import { list as hostTasks } from "../tasks/contract/client";
 import { peerPane } from "../hosts/peer-sessions";
 import { untrusted } from "./untrusted";
 
@@ -104,6 +104,8 @@ async function peerChatWaiting(
             : `its chat on ${link.hostName} couldn't say whether a question is open`,
     };
   }
+  // compat: task-contract-1. A machine without held-chat-facts is asked
+  // through its task list; drop this once every linked machine has it.
   const view = await hostTasks(link, true)
     .then(({ tasks, capabilities }) =>
       // One that can't say its chat's turn can't rule out an open question.

package/lib/orchestrator/testing.ts

@@ -2,7 +2,7 @@
 // test database.
 
 import { randomUUID } from "crypto";
-import { db } from "../db";
+import { db, insertSessionRow } from "../db";
 import { saveItem } from "../chat/store";
 import { createProject } from "../projects";
 import { createWorkspace, setProjectWorkspace } from "../workspaces";
@@ -16,20 +16,17 @@ export function seedSession(opts: {
   updatedAt?: string;
 }): string {
   const id = randomUUID();
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, view,
-       task_status, branch_name, updated_at)
-     VALUES (?, ?, ?, '/tmp', ?, ?, ?, ?, COALESCE(?, datetime('now')))`
-  ).run(
+  insertSessionRow(db, {
     id,
-    opts.name,
-    `claude-${id}`,
-    opts.projectId,
-    opts.view ?? "terminal",
-    opts.task ? "running" : null,
-    opts.branch ?? null,
-    opts.updatedAt ?? null
-  );
+    name: opts.name,
+    tmux_name: `claude-${id}`,
+    working_directory: "/tmp",
+    project_id: opts.projectId,
+    view: opts.view ?? "terminal",
+    task_status: opts.task ? "running" : null,
+    branch_name: opts.branch ?? null,
+    updated_at: opts.updatedAt,
+  });
   return id;
 }
 

package/lib/orchestrator/watcher.ts

@@ -18,6 +18,7 @@ import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
 import { followAskHeads } from "./ask-heads";
+import { followAskVerdicts } from "./ask-verdict";
 import { raiseHeldAsks } from "./held-asks";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
@@ -91,6 +92,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
     await raiseHeldAsks(workspaceId, facts).catch((error) =>
       console.error(`Raising held asks in ${workspaceId}:`, error)
     );
+    await followAskVerdicts(workspaceId, facts).catch((error) =>
+      console.error(`Judging asked commits in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()

package/lib/plans/features.ts

@@ -160,7 +160,7 @@ export function pieceOfSession(sessionId: string): FeaturePiece | undefined {
 export function prOf(p: FeaturePiece): number | null {
   if (!p.session_id) return null;
   const s = db
-    .prepare(`SELECT pr_number, project_id FROM sessions WHERE id = ?`)
+    .prepare(`SELECT pr_number, project_id FROM session_rows WHERE id = ?`)
     .get(p.session_id) as
     | { pr_number: number | null; project_id: string | null }
     | undefined;

package/lib/plans/release.ts

@@ -38,7 +38,7 @@ export interface ReleaseDeps {
 
 const sessionOf = (id: string | null) =>
   id
-    ? (db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
         | Session
         | undefined)
     : undefined;

package/lib/ports.ts

@@ -70,7 +70,7 @@ async function reclaimEnded(
 ): Promise<void> {
   const rows = db
     .prepare(
-      `SELECT id, tmux_name, task_status, host_id FROM sessions
+      `SELECT id, tmux_name, task_status, host_id FROM session_rows
        WHERE port_slot IS NOT NULL
          AND (archived_at IS NOT NULL OR task_status IN ('done', 'merged'))`
     )

package/lib/recipes/test-fixtures.ts

@@ -2,7 +2,7 @@
 // them, and a session standing in for a run's.
 
 import { randomUUID } from "crypto";
-import { db } from "../db";
+import { db, updateSessionRow } from "../db";
 import { createProject } from "../projects";
 import { createWorkspace, setProjectWorkspace } from "../workspaces";
 import { createRecipe } from "./store";
@@ -43,7 +43,6 @@ export function makeSession(
   db.prepare(
     `INSERT INTO sessions (id, name, tmux_name, working_directory, view) VALUES (?, 's', ?, '/tmp', 'chat')`
   ).run(id, `claude-${id}`);
-  for (const [k, v] of Object.entries(fields))
-    db.prepare(`UPDATE sessions SET ${k} = ? WHERE id = ?`).run(v, id);
+  updateSessionRow(db, id, fields);
   return id;
 }

package/lib/resurrect/find.ts

@@ -65,7 +65,7 @@ function rows(scope: EndedScope, limit: number, kind?: EndedKind): Row[] {
       `SELECT s.id, s.name, s.tmux_name, s.project_id, p.name AS project_name,
          s.task_status, s.archived_at, s.plan_phase,
          COALESCE(s.task_ended_at, s.archived_at, s.settled_at, s.updated_at) AS ended_at
-       FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+       FROM session_rows s LEFT JOIN projects p ON p.id = s.project_id
        WHERE ${where.join(" AND ")}
        ORDER BY ended_at DESC LIMIT ?`
     )