@saadnvd1/agent-os 0.3.484 → 0.3.485

package/lib/orchestrator/armed.ts

@@ -123,6 +123,7 @@ function fingerprint(
   return [
     head,
     pr.checks,
+    pr.mergeable,
     (f.task?.ciSettleIn ?? 0) > 0,
     getCheck(task.id, head, "review")?.status,
     getCheck(task.id, head, "scope")?.status,

package/lib/orchestrator/conditions.ts

@@ -89,6 +89,13 @@ function sessionConditions(
         ciKey(pr),
         `${who}: ${ciWord(pr)}${pr.checks === "pass" ? " and settled" : ""}`
       );
+    // Mergeable for a long while with no check in a repository that has CI:
+    // CI probably wasn't triggered. News once per head, never an escalation.
+    if (pr.checks === "none" && f.task?.ciSilentMs !== undefined)
+      add(
+        `ci-silent:${pr.number}:${pr.head ?? ""}`,
+        `${who}: PR #${pr.number} at ${(pr.head ?? "").slice(0, 7)} has been mergeable for ${Math.floor(f.task.ciSilentMs / 60000)}m with no CI check registered; CI may not have been triggered on this head`
+      );
   }
 
   const blocked = f.task?.blocked ?? null;

package/lib/orchestrator/describe.ts

@@ -17,7 +17,9 @@ export function ciWord(pr: TaskPR): string {
       ? `CI failed: ${untrusted("CI", pr.failing)}`
       : "CI failed";
   if (pr.checks === "pending") return "CI pending";
-  return "no CI";
+  return pr.mergeable === "CONFLICTING"
+    ? "conflicts with its base, no CI yet"
+    : "no checks yet";
 }
 
 export const shortId = (id: string) => id.slice(0, 8);

package/lib/orchestrator/external-gates.ts

@@ -75,6 +75,8 @@ export async function judgeExternal(
           checkCount: pr.checkCount ?? 0,
           committedAt: await commitTime(ext.repo, sha),
         }),
+        mergeable: pr.mergeable,
+        baseName: ext.base,
         review,
         blocked: null,
         waitingOn: null,

package/lib/orchestrator/external-pr.ts

@@ -63,7 +63,7 @@ export type GateTarget =
   | { kind: "external"; pr: ExternalPR };
 
 const FIELDS =
-  "number,url,state,headRefOid,headRefName,baseRefName,isDraft,labels,isCrossRepository,statusCheckRollup,body,title";
+  "number,url,state,headRefOid,headRefName,baseRefName,isDraft,labels,isCrossRepository,statusCheckRollup,body,title,mergeable";
 
 interface ViewedPR extends ListedPR {
   baseRefName?: string;

package/lib/orchestrator/facts.ts

@@ -18,7 +18,8 @@ import { sessionRowInfo } from "../session-meta";
 import { taskView, type TaskPR, type TaskState } from "../tasks";
 import { storedPR } from "../tasks/session";
 import { commitTime, repoOf } from "./repo";
-import { ciSettleIn } from "./task-state";
+import { CHECKLESS_MS, checklessFor, ciSettleIn } from "./task-state";
+import { repoHasCI } from "./repo-ci";
 
 export type FactStatus = "running" | "waiting" | "idle" | "dead";
 
@@ -47,6 +48,9 @@ export interface SessionFacts {
     // With CI green on the PR's head: seconds until it counts as settled
     // (task-state.ts), when the CI-green event goes out.
     ciSettleIn?: number;
+    // Set once a mergeable head in a repository with CI has had no checks
+    // for CHECKLESS_MS (task-state.ts): ms it has been without.
+    ciSilentMs?: number;
   } | null;
   stack: {
     id: string;
@@ -213,6 +217,20 @@ export async function settleIn(
   });
 }
 
+async function silentFor(
+  s: Session,
+  pr: TaskPR | null
+): Promise<number | undefined> {
+  if (!pr) return;
+  const silent = checklessFor(s.id, pr);
+  if (silent === undefined || silent < CHECKLESS_MS) return;
+  const ci = await repoHasCI(
+    repoOf(s),
+    `origin/${pr.base ?? s.base_branch ?? "main"}`
+  ).catch(() => "unknown");
+  return ci === "yes" ? silent : undefined;
+}
+
 // A finished task's state is in the database: no gh call for it.
 async function taskFacts(
   workspaceId: string,
@@ -230,6 +248,7 @@ async function taskFacts(
     pr: view.pr,
     blocked: view.blocked,
     ciSettleIn: await settleIn(workspaceId, s, view.pr),
+    ciSilentMs: await silentFor(s, view.pr),
   };
 }
 

package/lib/orchestrator/gates.ts

@@ -1,7 +1,8 @@
 /**
  * The merge gates, ported from dispatch orchestrate. Each one passes, waits
  * (not ready yet: CI running or settling, no review of this commit yet),
- * fails, or goes straight to Saad (no CI at all). Only a failure counts
+ * fails, or goes straight to Saad (the repository has no CI at all, never
+ * just a head with no checks). Only a failure counts
  * against the task, and a gate failing again on a different commit goes to
  * Saad instead of being retried. A failure counts once per task, gate and
  * head commit, whichever path judged it (the armed watcher, CI finishing,
@@ -12,9 +13,10 @@
 
 import { db } from "../db";
 import type { CodeReviewGate } from "../tasks/code-review";
-import type { ChecksVerdict } from "../tasks/state";
+import type { ChecksVerdict, TaskPR } from "../tasks/state";
 import type { CheckRow } from "./checks";
 import { APPROVAL_GATES, mergeApprovalsOn } from "./merge-approvals";
+import type { RepoCI } from "./repo-ci";
 import { untrusted } from "./untrusted";
 
 export type GateName =
@@ -37,6 +39,11 @@ export interface GateInput {
   failing?: string | null;
   // Seconds until CI on this commit counts as settled (tasks/task-state).
   settleIn: number;
+  // GitHub's word on merging the PR into its base, and that base's name.
+  mergeable?: TaskPR["mergeable"];
+  baseName?: string | null;
+  // Whether the repository has CI; only read when the head has no checks.
+  repoCI?: RepoCI;
   review: CheckRow | null;
   // A BLOCKED: line, or an approval or question the agent is waiting on.
   blocked: string | null;
@@ -68,22 +75,48 @@ function ciGate(i: GateInput): GateOutcome {
       state: "fail",
       reason: `CI failed on ${at}${i.failing ? ` (${untrusted("CI", i.failing)})` : ""}`,
     };
+  if (i.checks === "none") return noChecks(i, at);
   if (i.settleIn > 0)
     return {
       gate,
       state: "wait",
-      reason:
-        i.checks === "none"
-          ? `no CI checks have registered on ${at} yet (looking again in ${i.settleIn}s)`
-          : `CI is green on ${at} but settling: ${i.settleIn}s more with no new check`,
+      reason: `CI is green on ${at} but settling: ${i.settleIn}s more with no new check`,
     };
-  if (i.checks === "none")
+  return { gate, state: "pass" };
+}
+
+// A head with no checks. Only a repository with no CI at all has nothing to
+// gate on; in one with CI the head is not yet, whatever the reason.
+function noChecks(i: GateInput, at: string): GateOutcome {
+  const gate = "ci";
+  const wait = (reason: string): GateOutcome => ({
+    gate,
+    state: "wait",
+    reason,
+  });
+  if (i.mergeable === "CONFLICTING")
+    return wait(
+      `PR conflicts with ${i.baseName ?? "its base"}; CI can't run on ${at} until it's rebased`
+    );
+  if (i.settleIn > 0)
+    return wait(
+      `no CI checks have registered on ${at} yet (looking again in ${i.settleIn}s)`
+    );
+  if (i.repoCI === "no")
     return {
       gate,
       state: "escalate",
-      reason: `no CI ran on ${at}: this repository has no checks to gate a merge on`,
+      reason: `no CI ran on ${at}: this repository has no checks to gate a merge on (no workflow files, and no check has run on its default branch or recent PRs)`,
     };
-  return { gate, state: "pass" };
+  if (i.repoCI === "yes")
+    return wait(
+      i.mergeable === "UNKNOWN"
+        ? `no CI checks on ${at} yet: GitHub is still working out whether it merges cleanly`
+        : `no CI checks on ${at} yet: CI hasn't been triggered on this head`
+    );
+  return wait(
+    `no CI checks on ${at}, and whether this repository has CI couldn't be read; looking again`
+  );
 }
 
 // A stored check of this exact commit: missing, running or broken waits.

package/lib/orchestrator/repo-ci.ts

@@ -0,0 +1,104 @@
+/**
+ * Whether a repository has CI at all, decided from the repository and never
+ * from one head: workflow files on the base, else any check or status that
+ * ever ran on the default branch or the recent PRs. A head with no checks in
+ * a repository that has CI is not yet (its PR conflicts, or CI hasn't been
+ * triggered); only a repository without CI is one with nothing to gate on.
+ */
+
+import { getDefaultBranch } from "../git";
+import { git } from "../git-exec";
+import { run } from "../tasks/gh";
+import { repoSlug } from "./repo-slug";
+
+export type RepoCI = "yes" | "no" | "unknown";
+
+const YES_TTL_MS = 60 * 60 * 1000;
+const NO_TTL_MS = 10 * 60 * 1000;
+const cache = new Map<string, { at: number; ci: "yes" | "no" }>();
+
+export function clearRepoCI(): void {
+  cache.clear();
+}
+
+export interface RepoCIDeps {
+  // The files under .github/workflows on `ref`.
+  workflows: (repo: string, ref: string) => Promise<string[]>;
+  // How many checks or statuses ran on the default branch and the recent
+  // PRs; null when GitHub can't say.
+  history: (repo: string) => Promise<number | null>;
+  now: () => number;
+}
+
+const count = (out: string) => {
+  const n = Number(out.trim());
+  return out.trim() !== "" && Number.isInteger(n) && n >= 0 ? n : null;
+};
+
+export const repoCIDeps: RepoCIDeps = {
+  workflows: async (repo, ref) =>
+    (
+      await git(repo, ["ls-tree", "--name-only", ref, ".github/workflows/"], {
+        timeout: 10000,
+      })
+    )
+      .split("\n")
+      .filter((f) => /\.ya?ml$/i.test(f.trim())),
+  history: async (repo) => {
+    const slug = await repoSlug(repo);
+    if (!slug) return null;
+    const branch = await getDefaultBranch(repo);
+    const ask = (args: string[]) =>
+      run("gh", args, repo, 20000).then(count, () => null);
+    const counts = await Promise.all([
+      ask([
+        "api",
+        `repos/${slug}/commits/${branch}/check-runs?per_page=1`,
+        "--jq",
+        ".total_count",
+      ]),
+      ask([
+        "api",
+        `repos/${slug}/commits/${branch}/status`,
+        "--jq",
+        ".statuses | length",
+      ]),
+      ask([
+        "pr",
+        "list",
+        "--state",
+        "all",
+        "--limit",
+        "20",
+        "--json",
+        "statusCheckRollup",
+        "--jq",
+        "[.[] | (.statusCheckRollup // []) | length] | add // 0",
+      ]),
+    ]);
+    if (counts.some((c) => c !== null && c > 0)) return 1;
+    return counts.every((c) => c === 0) ? 0 : null;
+  },
+  now: Date.now,
+};
+
+// "unknown" when it can't be told (GitHub unreachable or backed off): the
+// ci gate waits on that, it never escalates or passes on a guess.
+export async function repoHasCI(
+  repo: string,
+  baseRef: string,
+  deps: RepoCIDeps = repoCIDeps
+): Promise<RepoCI> {
+  const hit = cache.get(repo);
+  if (hit && deps.now() - hit.at < (hit.ci === "yes" ? YES_TTL_MS : NO_TTL_MS))
+    return hit.ci;
+  const found = (ci: "yes" | "no") => {
+    cache.set(repo, { at: deps.now(), ci });
+    return ci;
+  };
+  if ((await deps.workflows(repo, baseRef).catch(() => [])).length)
+    return found("yes");
+  const seen = await deps.history(repo).catch(() => null);
+  if (seen === null) return "unknown";
+  return found(seen > 0 ? "yes" : "no");
+}

package/lib/orchestrator/signoff.ts

@@ -3,8 +3,9 @@
  * commit that was judged. With merge approvals on (merge-approvals.ts),
  * 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 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.
+ * 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.
  */
 
 import { MERGED_AS, type MergeMethod } from "../tasks/merge-policy";
@@ -32,6 +33,7 @@ import { heldVerdict } from "./held";
 import { mergeApprovalsOn } from "./merge-approvals";
 import { isPaused } from "./pause";
 import { commitTime, fetchRefs, repoOf } from "./repo";
+import { repoHasCI } from "./repo-ci";
 import { DIFF_CAP, review } from "./review";
 import { workspaceStack, workspaceTask } from "./targets";
 import { ciSettleIn, waitingState } from "./task-state";
@@ -112,6 +114,8 @@ export async function judge(
         checkCount: pr.checkCount ?? 0,
         committedAt: await commitTime(repo, sha),
       }),
+      mergeable: pr.mergeable,
+      baseName: pr.base ?? task.base_branch,
       review: getCheck(task.id, sha, "review"),
       ...(await waitingState(task)),
       fromCard: !!task.lh_card_id,
@@ -203,11 +207,17 @@ export async function gateVerdict(
     }
   }
 
-  const outcomes = evaluateGates({
-    sha,
-    ruleBreaks: ruleBreaks(files, await addedLines(repo, base, sha)),
-    ...(await inputs()),
-  });
+  const ruled = ruleBreaks(files, await addedLines(repo, base, sha));
+  const live = await inputs();
+  // Asked only when it can change the answer: a head with no checks that
+  // isn't settling or conflicting.
+  const repoCI =
+    live.checks === "none" &&
+    live.settleIn === 0 &&
+    live.mergeable !== "CONFLICTING"
+      ? await repoHasCI(repo, base)
+      : undefined;
+  const outcomes = evaluateGates({ sha, ruleBreaks: ruled, ...live, repoCI });
   const head = `${work.name} (PR #${pr.number} at ${short(sha)}) can't merge:`;
   const toSaad = outcomes.find((o) => o.state === "escalate");
   if (toSaad)

package/lib/orchestrator/task-state.ts

@@ -2,6 +2,7 @@
 // live inputs to the blocked and ci gates.
 
 import type { Session } from "../db";
+import type { TaskPR } from "../tasks/state";
 import { chatStateNow } from "../chat/runner";
 import { saidSinceLastMessage } from "../chat/store";
 import { blockedReason } from "../tasks/state";
@@ -139,3 +140,33 @@ export function ciSettleIn(input: {
   const settledAt = Math.max(input.committedAt, changedAt) + SETTLE_S;
   return Math.max(0, settledAt - now);
 }
+
+// A head with no checks for this long after its PR became mergeable, in a
+// repository with CI, is news for the orchestrator (never an escalation).
+export const CHECKLESS_MS = 30 * 60 * 1000;
+
+const checkless = new Map<string, number>();
+
+// How long this head has had no checks while its PR could merge cleanly, in
+// ms, or undefined when it isn't in that state. In memory: a restart only
+// restarts the clock.
+export function checklessFor(
+  taskId: string,
+  pr: Pick<TaskPR, "state" | "checks" | "head" | "mergeable">,
+  now = Date.now()
+): number | undefined {
+  const key = `${taskId}:${pr.head ?? ""}`;
+  for (const k of checkless.keys())
+    if (k.startsWith(`${taskId}:`) && k !== key) checkless.delete(k);
+  if (
+    pr.state !== "OPEN" ||
+    pr.checks !== "none" ||
+    pr.mergeable !== "MERGEABLE"
+  ) {
+    checkless.delete(key);
+    return undefined;
+  }
+  const since = checkless.get(key) ?? now;
+  checkless.set(key, since);
+  return now - since;
+}

package/package.json

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