@saadnvd1/agent-os 0.3.459 → 0.3.460

package/README.md

@@ -900,6 +900,18 @@ it may do on its own, and the lines that always come back to you as asks.
   unchanged (same `git patch-id`; a fresh review starts otherwise). Not
   clean: the task is asked once to rebase. Either way, one event. Main and
   other tasks' branches are never written.
+- **Tasks woken on CI failures and reviews:** a check failing on a task's
+  PR head messages the task's own agent once per head, with the check, the
+  failing step and about 60 lines of `gh run view --log-failed` around the
+  error, telling it to fix the root cause, push and update its Reviewed:
+  line. A review or comment from a collaborator (not the account gh runs
+  as, which is the task's own) wakes it once per review or comment; one
+  GraphQL query per repository a minute fingerprints the open task PRs, and
+  only a PR whose fingerprint moved has its reviews read. Comment-only wakes
+  stop at 10 a task; changes requested always wake. A task mid-turn gets it
+  queued, the orchestrator hears one line per wake, and merged, closed,
+  dropped or done tasks aren't watched. On by default; **Settings →
+  Workspaces** turns it off per workspace.
 - **External PRs and sessions:** `review` and `sign_off` also take an open
   PR no AgentOS task owns (dispatch, a person, dependabot) by `#N`,
   `owner/repo#N` or URL, as long as its repository is one of the workspace's

package/app/api/workspaces/[id]/route.ts

@@ -5,7 +5,13 @@ type RouteParams = { params: Promise<{ id: string }> };
 
 export async function PATCH(request: NextRequest, { params }: RouteParams) {
   const { id } = await params;
-  const { name, collapsed, sortOrder, maxRunningTasks } = await request.json();
+  const { name, collapsed, sortOrder, maxRunningTasks, wakeTasksOnPR } =
+    await request.json();
+  if (wakeTasksOnPR !== undefined && typeof wakeTasksOnPR !== "boolean")
+    return NextResponse.json(
+      { error: "wakeTasksOnPR is true or false" },
+      { status: 400 }
+    );
   let workspace;
   try {
     workspace = updateWorkspace(id, {
@@ -13,6 +19,7 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       collapsed,
       sortOrder,
       maxRunningTasks,
+      wakeTasksOnPR,
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/components/Workspaces/WorkspaceSettings.tsx

@@ -1,6 +1,7 @@
 "use client";
 
-import { useWorkspacesQuery } from "@/data/workspaces";
+import { SettingToggle } from "@/components/Settings/SettingToggle";
+import { useUpdateWorkspace, useWorkspacesQuery } from "@/data/workspaces";
 import { TaskLimitForm } from "./TaskLimitForm";
 import { RulesForm } from "./RulesForm";
 import { FreshStartForm } from "./FreshStartForm";
@@ -8,6 +9,7 @@ import { FreshStartForm } from "./FreshStartForm";
 // Settings > Workspaces: each workspace's own settings.
 export function WorkspaceSettings() {
   const { data: workspaces, isPending, isError, error } = useWorkspacesQuery();
+  const update = useUpdateWorkspace();
 
   if (isPending)
     return <div className="bg-muted/40 h-32 animate-pulse rounded-lg" />;
@@ -39,6 +41,12 @@ export function WorkspaceSettings() {
             workspace={w}
           />
           <RulesForm workspaceId={w.id} />
+          <SettingToggle
+            title="Wake tasks on CI failures and reviews"
+            detail="A task's agent is messaged once when a check fails on its PR's head, with the log's tail, and when someone reviews or comments on it."
+            checked={w.wake_tasks_on_pr}
+            onChange={(on) => update.mutate({ id: w.id, wakeTasksOnPR: on })}
+          />
         </section>
       ))}
       <FreshStartForm />

package/data/workspaces/index.ts

@@ -53,6 +53,8 @@ export function useUpdateWorkspace() {
       collapsed?: boolean;
       // Running tasks at once; null for no limit.
       maxRunningTasks?: number | null;
+      // Message tasks about failing checks and reviews on their PRs.
+      wakeTasksOnPR?: boolean;
     }) =>
       json(
         await fetch(`/api/workspaces/${id}`, {
@@ -61,7 +63,7 @@ export function useUpdateWorkspace() {
           body: JSON.stringify(updates),
         })
       ),
-    onMutate: async ({ id, maxRunningTasks, ...updates }) => {
+    onMutate: async ({ id, maxRunningTasks, wakeTasksOnPR, ...updates }) => {
       await queryClient.cancelQueries({ queryKey: workspaceKeys.list() });
       queryClient.setQueryData<Workspace[]>(workspaceKeys.list(), (prev) =>
         prev?.map((w) =>
@@ -72,6 +74,9 @@ export function useUpdateWorkspace() {
                 ...(maxRunningTasks !== undefined && {
                   max_running_tasks: maxRunningTasks,
                 }),
+                ...(wakeTasksOnPR !== undefined && {
+                  wake_tasks_on_pr: wakeTasksOnPR,
+                }),
               }
             : w
         )

package/lib/db/migrations.ts

@@ -1226,6 +1226,38 @@ const migrations: Migration[] = [
       installChangeTriggers(db, TABLES_WATCHED_56);
     },
   },
+  {
+    id: 57,
+    name: "task_pr_wakes",
+    up: (db) => {
+      // What a task's agent was told about its PR (orchestrator/pr-wake.ts),
+      // one row per failing head or review/comment id, claimed before the
+      // message goes. kind: check, review or comment (comments are capped).
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS task_pr_wakes (
+          session_id TEXT NOT NULL,
+          key TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          PRIMARY KEY (session_id, key)
+        );
+      `);
+      // pr_wake_since: reviews and comments older than this are taken as
+      // known when a task's PR is first watched.
+      const sessions = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+        name: string;
+      }[];
+      if (!sessions.some((c) => c.name === "pr_wake_since"))
+        db.exec(`ALTER TABLE sessions ADD COLUMN pr_wake_since TEXT`);
+      const workspaces = db.prepare(`PRAGMA table_info(workspaces)`).all() as {
+        name: string;
+      }[];
+      if (!workspaces.some((c) => c.name === "wake_tasks_on_pr"))
+        db.exec(
+          `ALTER TABLE workspaces ADD COLUMN wake_tasks_on_pr INTEGER NOT NULL DEFAULT 1`
+        );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -97,6 +97,8 @@ export interface Session {
   rebased_to?: string | null;
   // The PR head the task was last asked to rebase by hand.
   rebase_asked_head?: string | null;
+  // When its PR's reviews and comments started being watched (pr-wake.ts).
+  pr_wake_since?: string | null;
   // Orchestration fields
   conductor_session_id: string | null;
   worker_task: string | null;
@@ -204,6 +206,9 @@ export interface Workspace {
   orch_paused_at: string | null;
   // Tasks running at once before new ones queue (lib/tasks/queue.ts); null: no limit.
   max_running_tasks: number | null;
+  // Tasks are messaged about failing checks and reviews on their PRs
+  // (orchestrator/pr-wake.ts).
+  wake_tasks_on_pr: boolean;
   created_at: string;
 }
 

package/lib/orchestrator/brief.ts

@@ -52,6 +52,8 @@ Arm a task once its work is what you want merged, rather than calling \`sign_off
 
 When the base moves and a task's PR conflicts with it, AgentOS rebases it onto the base by itself if that's clean and its agent is idle with nothing uncommitted, pushes only the task's own branch, and tells you with one event. The task's Code review section still covers the rebased head, and your review of the old head carries over when the PR's own patch is unchanged (a fresh one starts otherwise). If it conflicts, the task is asked once to rebase and you get one event; don't send it the same request.
 
+Tasks are woken by AgentOS itself when a check fails on their PR's head (with the failing step and the log around the error) and when a collaborator reviews or comments on their PR, and you get one "task X woken: ..." line for each. Don't message a task about the same failure or review; act only if it doesn't fix it.
+
 "Not yet" (CI running or settling, no review of this commit yet) is not a failure: wait for the event and try again. A failure counts against the task: a review that blocks counts when its verdict arrives, once per commit, and the second failure of the same gate goes to Saad, with a note in your chat, and from then on only he merges or drops that task. Don't retry it; say so in your chat and move on. ${mergeApprovalsOn() ? APPROVALS_ON : APPROVALS_OFF} \`land\` merges a whole stack only if every open item passes the same gates, and judges each one again at its own head right before merging it.
 
 ## Brakes

package/lib/orchestrator/conditions.ts

@@ -8,7 +8,7 @@
  */
 
 import { db, type StackItemStatus, type StackStatus } from "../db";
-import { isFinished } from "../tasks/state";
+import { isFinished, type TaskPR } from "../tasks/state";
 import { ciWord } from "./describe";
 import type { SessionFacts } from "./facts";
 import { untrusted } from "./untrusted";
@@ -46,6 +46,13 @@ function hash(text: string): string {
   return (h >>> 0).toString(36);
 }
 
+// A session's condition is keyed by what it is and the session.
+export const conditionKey = (key: string, sessionId: string) =>
+  `${key}:${sessionId}`;
+// A PR's CI verdict on a head.
+export const ciKey = (pr: Pick<TaskPR, "number" | "head" | "checks">) =>
+  `ci:${pr.number}:${pr.head ?? ""}:${pr.checks}`;
+
 function sessionConditions(
   f: SessionFacts,
   now: number,
@@ -60,7 +67,7 @@ function sessionConditions(
     waiting = false
   ) =>
     out.push({
-      key: `${key}:${f.id}`,
+      key: conditionKey(key, f.id),
       subject: f.id,
       line,
       sticky,
@@ -79,7 +86,7 @@ function sessionConditions(
     const settling = pr.checks === "pass" && (f.task?.ciSettleIn ?? 0) > 0;
     if ((pr.checks === "pass" && !settling) || pr.checks === "fail")
       add(
-        `ci:${pr.number}:${pr.head ?? ""}:${pr.checks}`,
+        ciKey(pr),
         `${who}: ${ciWord(pr)}${pr.checks === "pass" ? " and settled" : ""}`
       );
   }

package/lib/orchestrator/pr-wake.ts

@@ -0,0 +1,385 @@
+/**
+ * Wakes a task's own agent when its PR needs it, so the orchestrator
+ * doesn't have to pass the news on. Runs in the watcher's merge pipeline,
+ * off the PR poll AgentOS already makes (no poller of its own):
+ *
+ * - A failing check on the PR's head: the task hears it once per head,
+ *   with the check's name, the failing step and the log around the error
+ *   (`gh run view --log-failed`, trimmed). Read from the rollup the poll
+ *   already has, so only the log costs a call.
+ * - A review or conversation comment from a collaborator other than the
+ *   account gh runs as (which is the task's own): one GraphQL query per
+ *   repository a minute fingerprints every watched PR, and a PR's reviews
+ *   and comments are read only when its fingerprint moved. Comment-only
+ *   wakes stop at COMMENT_WAKE_CAP a task; changes requested always wake.
+ *
+ * Each event is claimed in task_pr_wakes before its message goes, so it's
+ * sent once across restarts. Messages go through the bus like any other:
+ * a task mid-turn gets it queued, never interrupted. The orchestrator hears
+ * one line per wake. Only open PRs of running tasks are watched: merged,
+ * closed, dropped or done stops it. Off per workspace in Settings.
+ */
+
+import { db, type Session } from "../db";
+import { sendMessage } from "../bus";
+import { getWorkspace } from "../workspaces";
+import { OPEN_TTL_MS } from "../tasks/pr-poll";
+import {
+  failedLog,
+  fingerprints,
+  prActivity,
+  repoOfPR,
+  type FailedLog,
+  type Fingerprint,
+  type PREvent,
+  type Repo,
+} from "../tasks/pr-activity";
+import type { TaskPR } from "../tasks/state";
+import { ciKey, conditionKey } from "./conditions";
+import { markTold, queueEvent } from "./events";
+import type { SessionFacts } from "./facts";
+import { isPaused } from "./pause";
+import { repoOf } from "./repo";
+import { untrusted, UNTRUSTED_RULE } from "./untrusted";
+
+export const COMMENT_WAKE_CAP = 10;
+// A first look at a PR this young takes its whole history as new.
+const YOUNG_PR_MS = 10 * 60_000;
+// Collaborators only: anyone can comment on a public repository's PR.
+const TRUSTED = new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
+const BODY_MAX = 800;
+const NOTE_MAX = 300;
+const NOTES_MAX = 10;
+const SEND_TRIES = 3;
+
+export interface WakeDeps {
+  fingerprints: typeof fingerprints;
+  activity: typeof prActivity;
+  failedLog: typeof failedLog;
+  // Message the task's agent through the bus; throws when it failed.
+  send: (task: Session, body: string) => Promise<unknown>;
+}
+
+// As an AgentOS event, through the bus: queued while the agent is mid-turn.
+export async function sendWake(task: Session, body: string) {
+  const { delivery } = await sendMessage({
+    fromId: null,
+    to: task.id,
+    body,
+    fromLabel: "AgentOS",
+    origin: { kind: "event", label: "AgentOS", body },
+    // A chat agent reads it whole; a terminal's is told to read its inbox.
+    line: task.view === "chat" ? `[AgentOS event] ${body}` : undefined,
+  });
+  if (delivery.state === "failed") throw new Error(delivery.why);
+  return delivery.state;
+}
+
+const defaults: WakeDeps = {
+  fingerprints,
+  activity: prActivity,
+  failedLog,
+  send: sendWake,
+};
+
+const short = (sha: string) => sha.slice(0, 7);
+const clip = (s: string, n: number) => (s.length > n ? `${s.slice(0, n)}…` : s);
+
+// The fingerprint each task's PR was last handled at, and when each
+// repository was last fingerprinted.
+const handled = new Map<string, string>();
+const polled = new Map<string, number>();
+// Sends that failed, per task and key, so a broken one stops retrying.
+const failures = new Map<string, number>();
+
+const sessionRow = (id: string) =>
+  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+
+// True when this call took the key; false when it was taken before.
+const claim = (task: string, key: string, kind: string) =>
+  db
+    .prepare(
+      `INSERT OR IGNORE INTO task_pr_wakes (session_id, key, kind) VALUES (?, ?, ?)`
+    )
+    .run(task, key, kind).changes > 0;
+
+const taken = (task: string, key: string) =>
+  !!db
+    .prepare(`SELECT 1 FROM task_pr_wakes WHERE session_id = ? AND key = ?`)
+    .get(task, key);
+
+const unclaim = (task: string, keys: string[]) => {
+  const del = db.prepare(
+    `DELETE FROM task_pr_wakes WHERE session_id = ? AND key = ?`
+  );
+  for (const key of keys) del.run(task, key);
+};
+
+export const commentWakes = (task: string) =>
+  (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM task_pr_wakes WHERE session_id = ? AND kind = 'comment'`
+      )
+      .get(task) as { n: number }
+  ).n;
+
+interface Watched {
+  task: Session;
+  pr: TaskPR & { head: string };
+  repo: Repo;
+  dir: string;
+}
+
+export async function wakeTasks(
+  workspaceId: string,
+  facts: SessionFacts[],
+  deps: WakeDeps = defaults,
+  now = Date.now()
+): Promise<void> {
+  if (!getWorkspace(workspaceId)?.wake_tasks_on_pr || isPaused(workspaceId))
+    return;
+  const watched: Watched[] = [];
+  for (const f of facts) {
+    const pr = f.task?.pr;
+    const task = pr?.state === "OPEN" && pr.head ? sessionRow(f.id) : null;
+    const repo = pr && repoOfPR(pr.url);
+    if (!task || task.task_status !== "running" || !repo || !pr?.head) {
+      handled.delete(f.id);
+      continue;
+    }
+    let dir: string;
+    try {
+      dir = repoOf(task);
+    } catch {
+      continue;
+    }
+    watched.push({ task, pr: { ...pr, head: pr.head }, repo, dir });
+  }
+
+  for (const w of watched) {
+    if (isPaused(workspaceId)) return;
+    if (w.pr.checks !== "fail" || !w.pr.failing) continue;
+    await wakeOnCheck(workspaceId, w, deps).catch((error) =>
+      console.error(`Waking ${w.task.name} on CI:`, error)
+    );
+  }
+
+  const byRepo = new Map<string, Watched[]>();
+  for (const w of watched) {
+    const slug = `${w.repo.owner}/${w.repo.name}`;
+    byRepo.set(slug, [...(byRepo.get(slug) ?? []), w]);
+  }
+  for (const [slug, group] of byRepo) {
+    if (isPaused(workspaceId)) return;
+    if (now - (polled.get(slug) ?? 0) < OPEN_TTL_MS) continue;
+    polled.set(slug, now);
+    let prints: Map<number, Fingerprint>;
+    try {
+      prints = await deps.fingerprints(
+        group[0].dir,
+        group[0].repo,
+        group.map((w) => w.pr.number)
+      );
+    } catch (error) {
+      console.error(`Fingerprinting PRs in ${slug}:`, error);
+      continue;
+    }
+    for (const w of group) {
+      const print = prints.get(w.pr.number);
+      if (!print || handled.get(w.task.id) === print.print) continue;
+      try {
+        if (await wakeOnReviews(workspaceId, w, print, deps, now))
+          handled.set(w.task.id, print.print);
+      } catch (error) {
+        console.error(`Waking ${w.task.name} on reviews:`, error);
+      }
+    }
+  }
+}
+
+// Whether the task is still to be woken now, after the gh calls since it
+// was read: not paused or turned off, and the task still running.
+const stillWatched = (workspaceId: string, taskId: string) =>
+  !isPaused(workspaceId) &&
+  !!getWorkspace(workspaceId)?.wake_tasks_on_pr &&
+  sessionRow(taskId)?.task_status === "running";
+
+// Sends after claiming `keys`; a failed send gives them back for the next
+// poll, SEND_TRIES times. False when it didn't go.
+async function wake(
+  workspaceId: string,
+  w: Watched,
+  keys: string[],
+  body: string,
+  deps: WakeDeps
+): Promise<boolean> {
+  if (!stillWatched(workspaceId, w.task.id)) {
+    unclaim(w.task.id, keys);
+    return false;
+  }
+  try {
+    await deps.send(w.task, body);
+    return true;
+  } catch (error) {
+    const id = `${w.task.id}\0${keys[0]}`;
+    const n = (failures.get(id) ?? 0) + 1;
+    failures.set(id, n);
+    console.error(`Messaging ${w.task.name} (try ${n}):`, error);
+    if (n < SEND_TRIES) unclaim(w.task.id, keys);
+    return false;
+  }
+}
+
+async function wakeOnCheck(
+  workspaceId: string,
+  w: Watched,
+  deps: WakeDeps
+): Promise<void> {
+  const { task, pr } = w;
+  const key = `check:${pr.head}`;
+  if (taken(task.id, key)) return;
+  const log: FailedLog | null = await deps
+    .failedLog(w.dir, w.repo, pr.failingUrl)
+    .catch((error: unknown) => {
+      console.error(`Reading ${task.name}'s CI log:`, error);
+      return null;
+    });
+  // Claimed only now, next to the send, so a restart while the log is
+  // read doesn't lose the wake.
+  if (!claim(task.id, key, "check")) return;
+  if (!(await wake(workspaceId, w, [key], checkMessage(pr, log), deps))) return;
+  queueEvent(
+    workspaceId,
+    `woke:${task.id}:${key}`,
+    task.id,
+    `task ${task.name} woken: CI ${untrusted("CI", pr.failing!)} failed at ${short(pr.head)}`
+  );
+  // The orchestrator's own "CI failed" line for this head would only
+  // repeat it.
+  markTold(workspaceId, conditionKey(ciKey(pr), task.id), task.id);
+}
+
+export function checkMessage(
+  pr: TaskPR & { head: string },
+  log: FailedLog | null
+): string {
+  const step = log?.step ? ` at step ${untrusted("CI", log.step)}` : "";
+  const tail = log?.tail
+    ? `\n\nThe log around the error:\n${untrusted("CI log", log.tail)}`
+    : pr.failingUrl
+      ? `\n\nIts details: ${untrusted("CI", pr.failingUrl)}`
+      : "";
+  return `CI check ${untrusted("CI", pr.failing ?? "")} failed on your PR #${pr.number} at ${short(pr.head)}${step}.${tail}\n\n${UNTRUSTED_RULE}\n\nFix the root cause (not the check), re-run your checks, push, then run /do-code-review again and update the Reviewed: line in the PR body for the new head.`;
+}
+
+// True once the PR's activity at this fingerprint has been handled.
+async function wakeOnReviews(
+  workspaceId: string,
+  w: Watched,
+  print: Fingerprint,
+  deps: WakeDeps,
+  now: number
+): Promise<boolean> {
+  const { task, pr } = w;
+  const since = Date.parse(watchSince(task, print, now));
+  const activity = await deps.activity(w.dir, w.repo, pr.number);
+  const fresh = activity.events.filter(
+    (e) =>
+      e.author !== activity.viewer &&
+      TRUSTED.has(e.association) &&
+      Date.parse(e.at) >= since &&
+      worthWaking(e) &&
+      !taken(task.id, `event:${e.id}`)
+  );
+  if (!fresh.length) return true;
+  const changes = fresh.some((e) => e.state === "CHANGES_REQUESTED");
+  const kind = changes ? "review" : "comment";
+  const keys = fresh.map((e) => `event:${e.id}`);
+  if (!changes && commentWakes(task.id) >= COMMENT_WAKE_CAP) {
+    for (const key of keys) claim(task.id, key, "event");
+    if (claim(task.id, "capped", "capped"))
+      queueEvent(
+        workspaceId,
+        `woke:${task.id}:capped`,
+        task.id,
+        `task ${task.name}: ${COMMENT_WAKE_CAP} comment wakes on PR #${pr.number} reached; further comments won't wake it`
+      );
+    return true;
+  }
+  const wakeKey = `wake:${fresh[0].id}`;
+  const claimed = [wakeKey, ...keys].filter((key, i) =>
+    claim(task.id, key, i === 0 ? kind : "event")
+  );
+  if (!claimed.includes(wakeKey)) return true;
+  if (!(await wake(workspaceId, w, claimed, reviewMessage(pr, fresh), deps)))
+    return false;
+  const who = [...new Set(fresh.map((e) => e.author))].join(", ");
+  queueEvent(
+    workspaceId,
+    `woke:${task.id}:${wakeKey}`,
+    task.id,
+    `task ${task.name} woken: ${changes ? "changes requested" : fresh.length === 1 ? "a review comment" : `${fresh.length} review comments`} on PR #${pr.number} from ${who}`
+  );
+  return true;
+}
+
+// An approval or a dismissed review with nothing to say asks for nothing.
+const worthWaking = (e: PREvent) =>
+  e.state !== "PENDING" &&
+  e.state !== "DISMISSED" &&
+  (e.state === "CHANGES_REQUESTED" || !!e.body.trim() || e.notes.length > 0);
+
+// When this PR's reviews started being watched, set on the first look:
+// a young PR from its start, an older one from now, so what was said
+// before this watched it isn't news.
+function watchSince(task: Session, print: Fingerprint, now: number): string {
+  if (task.pr_wake_since) return task.pr_wake_since;
+  const created = Date.parse(print.createdAt);
+  const since =
+    Number.isFinite(created) && now - created < YOUNG_PR_MS
+      ? new Date(created).toISOString()
+      : new Date(now).toISOString();
+  db.prepare(`UPDATE sessions SET pr_wake_since = ? WHERE id = ?`).run(
+    since,
+    task.id
+  );
+  task.pr_wake_since = since;
+  return since;
+}
+
+export function reviewMessage(pr: TaskPR, events: PREvent[]): string {
+  const items = events.map((e) => {
+    const what =
+      e.state === "CHANGES_REQUESTED"
+        ? "requested changes"
+        : e.kind === "review"
+          ? "reviewed"
+          : "commented";
+    const body = e.body.trim()
+      ? `: ${untrusted(e.author, clip(e.body.trim(), BODY_MAX))}`
+      : "";
+    const notes = e.notes
+      .slice(0, NOTES_MAX)
+      .map(
+        (n) =>
+          `\n  - ${n.path}${n.line ? `:${n.line}` : ""}: ${untrusted(e.author, clip(n.body.trim(), NOTE_MAX))}`
+      )
+      .join("");
+    const more =
+      e.notes.length > NOTES_MAX
+        ? `\n  - and ${e.notes.length - NOTES_MAX} more on the PR`
+        : "";
+    return `- ${e.author} ${what}${body}${notes}${more}`;
+  });
+  return `New review activity on your PR #${pr.number}:\n${items.join("\n")}\n\n${UNTRUSTED_RULE} Address each point: fix what's right, re-run your checks, push, then run /do-code-review again and update the Reviewed: line for the new head. Where you disagree, reply on the PR (\`gh pr comment ${pr.number}\`) saying why.`;
+}
+
+// Tests only.
+export function resetPRWake(): void {
+  handled.clear();
+  polled.clear();
+  failures.clear();
+}

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 { rebaseConflicting } from "./rebase";
+import { wakeTasks } from "./pr-wake";
 
 // Asks that stopped needing Saad: their task or PR finished some other
 // way, or brakes lifted with nothing trying to start.
@@ -61,8 +62,8 @@ export async function diffWorkspace(
   return nextDiffAt(now, facts, working);
 }
 
-// Rebases what conflicts with its base, then merges what's armed and
-// passes. In the background, one run per workspace at a time, so a git
+// Wakes tasks whose PRs failed CI or got reviews, rebases what conflicts
+// with its base, then merges what's armed and passes. In the background, one run per workspace at a time, so a git
 // fetch or a merge never holds up event delivery.
 const piping = new Set<string>();
 
@@ -70,6 +71,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
   if (piping.has(workspaceId)) return;
   piping.add(workspaceId);
   void (async () => {
+    await wakeTasks(workspaceId, facts).catch((error) =>
+      console.error(`Waking tasks in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()

package/lib/tasks/gh.ts

@@ -6,6 +6,7 @@ import { assertGhAllowed, noteGhFailure, noteGhSuccess } from "./gh-limit";
 import {
   checksVerdict,
   failingCheck,
+  failingUrl,
   rerunsToLookUp,
   settleReruns,
   type ActionsRun,
@@ -106,6 +107,7 @@ export async function toTaskPR(repoDir: string, pr: ListedPR): Promise<TaskPR> {
     checks: checksVerdict(rollup),
     head: pr.headRefOid,
     failing: failingCheck(rollup),
+    failingUrl: failingUrl(rollup),
     checkCount: (pr.statusCheckRollup ?? []).length,
     codeReview: pr.body === undefined ? undefined : parseCodeReview(pr.body),
     scopeChange: parseScopeChange(pr.body),

package/lib/tasks/pr-activity.ts

@@ -0,0 +1,295 @@
+// Reviews and comments on task PRs, read in two steps: a fingerprint of
+// every watched PR in a repository from one GraphQL query (counts and the
+// latest ids), and one PR's reviews and comments only when its fingerprint
+// moved. Plus the part of a failed Actions job's log around its error.
+
+import { redact } from "../orchestrator/untrusted";
+import { run } from "./gh";
+
+export interface Repo {
+  owner: string;
+  name: string;
+}
+
+export const repoOfPR = (url: string): Repo | null => {
+  const m = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/\d+/.exec(url);
+  return m ? { owner: m[1], name: m[2] } : null;
+};
+
+export interface Fingerprint {
+  // Changes whenever a review or a conversation comment is added.
+  print: string;
+  createdAt: string;
+}
+
+const graphql = async (
+  dir: string,
+  query: string,
+  vars: Record<string, string | number>
+) => {
+  const args = ["api", "graphql", "-f", `query=${query}`];
+  for (const [k, v] of Object.entries(vars))
+    args.push(typeof v === "number" ? "-F" : "-f", `${k}=${v}`);
+  return JSON.parse(await run("gh", args, dir, 30000)) as {
+    data?: { viewer?: { login: string }; repository?: Record<string, unknown> };
+  };
+};
+
+type Last = { totalCount: number; nodes: { id: string }[] };
+
+// One query for all the given PRs of a repository.
+export async function fingerprints(
+  dir: string,
+  repo: Repo,
+  numbers: number[]
+): Promise<Map<number, Fingerprint>> {
+  const prs = numbers.filter((n) => Number.isInteger(n) && n > 0);
+  const out = new Map<number, Fingerprint>();
+  if (!prs.length) return out;
+  const fields = prs
+    .map(
+      (n) =>
+        `p${n}: pullRequest(number: ${n}) { createdAt reviews(last: 1) { totalCount nodes { id } } comments(last: 1) { totalCount nodes { id } } }`
+    )
+    .join(" ");
+  const res = await graphql(
+    dir,
+    `query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { ${fields} } }`,
+    { owner: repo.owner, name: repo.name }
+  );
+  for (const n of prs) {
+    const pr = res.data?.repository?.[`p${n}`] as
+      | { createdAt: string; reviews: Last; comments: Last }
+      | null
+      | undefined;
+    if (!pr) continue;
+    const part = (l: Last) => `${l.totalCount}:${l.nodes[0]?.id ?? ""}`;
+    out.set(n, {
+      print: `${part(pr.reviews)}/${part(pr.comments)}`,
+      createdAt: pr.createdAt,
+    });
+  }
+  return out;
+}
+
+export interface PRNote {
+  path: string;
+  line: number | null;
+  body: string;
+}
+
+export interface PREvent {
+  id: string;
+  kind: "review" | "comment";
+  // A review's: APPROVED, CHANGES_REQUESTED, COMMENTED, DISMISSED, PENDING.
+  state: string | null;
+  author: string;
+  // GitHub's word on the author: OWNER, MEMBER, COLLABORATOR, NONE...
+  association: string;
+  at: string;
+  body: string;
+  // A review's inline comments.
+  notes: PRNote[];
+}
+
+export interface PRActivity {
+  // Who gh is signed in as: the task's own comments are posted as this.
+  viewer: string;
+  events: PREvent[];
+}
+
+type Author = { login: string } | null;
+
+// The latest reviews and conversation comments on one PR.
+export async function prActivity(
+  dir: string,
+  repo: Repo,
+  number: number
+): Promise<PRActivity> {
+  const res = await graphql(
+    dir,
+    `
+      query ($owner: String!, $name: String!, $number: Int!) {
+        viewer {
+          login
+        }
+        repository(owner: $owner, name: $name) {
+          pullRequest(number: $number) {
+            reviews(last: 30) {
+              nodes {
+                id
+                state
+                body
+                submittedAt
+                authorAssociation
+                author {
+                  login
+                }
+                comments(first: 20) {
+                  nodes {
+                    path
+                    line
+                    originalLine
+                    body
+                  }
+                }
+              }
+            }
+            comments(last: 30) {
+              nodes {
+                id
+                body
+                createdAt
+                authorAssociation
+                author {
+                  login
+                }
+              }
+            }
+          }
+        }
+      }
+    `,
+    { owner: repo.owner, name: repo.name, number }
+  );
+  const pr = res.data?.repository?.pullRequest as
+    | {
+        reviews: {
+          nodes: {
+            id: string;
+            state: string;
+            body: string;
+            submittedAt: string | null;
+            authorAssociation: string;
+            author: Author;
+            comments: {
+              nodes: {
+                path: string;
+                line: number | null;
+                originalLine: number | null;
+                body: string;
+              }[];
+            };
+          }[];
+        };
+        comments: {
+          nodes: {
+            id: string;
+            body: string;
+            createdAt: string;
+            authorAssociation: string;
+            author: Author;
+          }[];
+        };
+      }
+    | null
+    | undefined;
+  if (!pr || !res.data?.viewer) throw new Error(`PR #${number} not found`);
+  return {
+    viewer: res.data.viewer.login,
+    events: [
+      ...pr.reviews.nodes
+        .filter((r) => r.submittedAt)
+        .map((r) => ({
+          id: r.id,
+          kind: "review" as const,
+          state: r.state,
+          author: r.author?.login ?? "ghost",
+          association: r.authorAssociation,
+          at: r.submittedAt!,
+          body: r.body ?? "",
+          notes: r.comments.nodes.map((c) => ({
+            path: c.path,
+            line: c.line ?? c.originalLine,
+            body: c.body ?? "",
+          })),
+        })),
+      ...pr.comments.nodes.map((c) => ({
+        id: c.id,
+        kind: "comment" as const,
+        state: null,
+        author: c.author?.login ?? "ghost",
+        association: c.authorAssociation,
+        at: c.createdAt,
+        body: c.body ?? "",
+        notes: [],
+      })),
+    ].sort((a, b) => Date.parse(a.at) - Date.parse(b.at)),
+  };
+}
+
+export const LOG_LINES = 60;
+const LINE_MAX = 240;
+// The line a failure is reported on; the runner's own last line isn't it.
+const ERROR =
+  /##\[error\]|\berror\b|\bfail(ed|ure|s)?\b|\bFAIL\b|✗|×|AssertionError|panic:/i;
+const RUNNER_EXIT = /Process completed with exit code/;
+
+export interface FailedLog {
+  step: string | null;
+  tail: string;
+}
+
+// `gh run view --log-failed` lines are "job<TAB>step<TAB>time text". Keeps
+// LOG_LINES lines from a little before the first error, without timestamps,
+// colour codes or anything token-shaped.
+export function trimLog(raw: string, max = LOG_LINES): FailedLog {
+  const rows = raw
+    .split("\n")
+    .filter((l) => l.trim())
+    .map((l) => {
+      const parts = l.split("\t");
+      const step = parts.length >= 3 ? parts[1] : null;
+      const text = (parts.length >= 3 ? parts.slice(2).join("\t") : l)
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, "")
+        .replace(/^?\d{4}-\d\d-\d\dT[\d:.]+Z ?/, "");
+      return {
+        step,
+        text: text.length > LINE_MAX ? `${text.slice(0, LINE_MAX)}…` : text,
+      };
+    });
+  if (!rows.length) return { step: null, tail: "" };
+  const hit = rows.findIndex(
+    (r) => ERROR.test(r.text) && !RUNNER_EXIT.test(r.text)
+  );
+  const anchor = hit >= 0 ? hit : rows.length - 1;
+  const start =
+    hit >= 0
+      ? Math.max(0, Math.min(hit - Math.floor(max / 3), rows.length - max))
+      : Math.max(0, rows.length - max);
+  const kept = rows.slice(start, start + max);
+  return {
+    step: rows[anchor].step,
+    tail: redact(kept.map((r) => r.text).join("\n")),
+  };
+}
+
+// The Actions job a check's details URL points at.
+export const jobOf = (url: string | null | undefined) =>
+  url ? (/\/actions\/runs\/\d+\/job\/(\d+)/.exec(url)?.[1] ?? null) : null;
+
+// The failed steps' log of an Actions job, trimmed; null for a check that
+// isn't an Actions job.
+export async function failedLog(
+  dir: string,
+  repo: Repo,
+  url: string | null | undefined
+): Promise<FailedLog | null> {
+  const job = jobOf(url);
+  if (!job) return null;
+  const raw = await run(
+    "gh",
+    [
+      "run",
+      "view",
+      "--repo",
+      `${repo.owner}/${repo.name}`,
+      "--job",
+      job,
+      "--log-failed",
+    ],
+    dir,
+    60000
+  );
+  return trimLog(raw);
+}

package/lib/tasks/state.ts

@@ -18,6 +18,8 @@ export interface TaskPR {
   // The head commit the checks ran on, and the first failing check's name.
   head?: string;
   failing?: string | null;
+  // Where that check's run is (an Actions job URL for a workflow check).
+  failingUrl?: string | null;
   // How many checks are registered on the head.
   checkCount?: number;
   // The body's Code review section: null when it has none, undefined
@@ -340,11 +342,17 @@ export function blockedReason(paneTail: string): string | null {
 }
 
 // The first failing check in gh's statusCheckRollup, by name.
+const firstFailing = (rollup: RollupEntry[]) =>
+  liveChecks(rollup).find((r) => FAILED.includes(outcome(r)));
+
 export function failingCheck(rollup: RollupEntry[]): string | null {
-  const c = liveChecks(rollup).find((r) => FAILED.includes(outcome(r)));
+  const c = firstFailing(rollup);
   return c ? (c.name ?? c.context ?? null) : null;
 }
 
+export const failingUrl = (rollup: RollupEntry[]): string | null =>
+  firstFailing(rollup)?.detailsUrl ?? null;
+
 // Keys that answer Claude's folder-trust prompt with "trust", or null when the
 // pane isn't showing it. The selection marker starts on "No, exit".
 export function trustPromptKeys(pane: string): string[] | null {

package/lib/workspaces.ts

@@ -6,11 +6,15 @@
 import { randomUUID } from "crypto";
 import { db, type Workspace } from "./db";
 
-type WorkspaceRow = Omit<Workspace, "collapsed"> & { collapsed: number };
+type WorkspaceRow = Omit<Workspace, "collapsed" | "wake_tasks_on_pr"> & {
+  collapsed: number;
+  wake_tasks_on_pr: number;
+};
 
 const toWorkspace = (row: WorkspaceRow): Workspace => ({
   ...row,
   collapsed: !!row.collapsed,
+  wake_tasks_on_pr: !!row.wake_tasks_on_pr,
 });
 
 export function listWorkspaces(): Workspace[] {
@@ -57,18 +61,20 @@ export function updateWorkspace(
     collapsed?: boolean;
     sortOrder?: number;
     maxRunningTasks?: number | null;
+    wakeTasksOnPR?: boolean;
   }
 ): Workspace | null {
   const existing = getWorkspace(id);
   if (!existing) return null;
   const name = updates.name?.trim() || existing.name;
   db.prepare(
-    `UPDATE workspaces SET name = ?, collapsed = ?, sort_order = ?, max_running_tasks = ? WHERE id = ?`
+    `UPDATE workspaces SET name = ?, collapsed = ?, sort_order = ?, max_running_tasks = ?, wake_tasks_on_pr = ? WHERE id = ?`
   ).run(
     name,
     (updates.collapsed ?? existing.collapsed) ? 1 : 0,
     updates.sortOrder ?? existing.sort_order,
     taskLimit(updates.maxRunningTasks, existing.max_running_tasks),
+    (updates.wakeTasksOnPR ?? existing.wake_tasks_on_pr) ? 1 : 0,
     id
   );
   return getWorkspace(id);

package/package.json

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