@saadnvd1/agent-os 0.3.457 → 0.3.460

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/presence-binding.ts

@@ -10,6 +10,8 @@ export const askPresence = (askId: number, binding: string) =>
 export const resumePresence = (workspaceId: string) => `resume:${workspaceId}`;
 export const revokePresence = (passkeyId: string) => `revoke:${passkeyId}`;
 export const APPROVALS_OFF_PRESENCE = "approvals-off";
+// Writing a workspace's standing rules as Saad.
+export const rulesPresence = (workspaceId: string) => `rules:${workspaceId}`;
 
 export function presenceBinding(b: {
   purpose?: PresencePurpose;
@@ -36,6 +38,9 @@ export function presenceBinding(b: {
       return "enroll";
     case "approvals-off":
       return APPROVALS_OFF_PRESENCE;
+    case "rules":
+      if (!b.workspaceId) throw new PresenceError("Which workspace?");
+      return rulesPresence(b.workspaceId);
     case "revoke":
       if (!b.passkeyId) throw new PresenceError("Which passkey?");
       return revokePresence(b.passkeyId);

package/lib/orchestrator/rules.ts

@@ -0,0 +1,124 @@
+/**
+ * A workspace's standing rules: what its orchestrator must keep knowing
+ * across fresh starts ("never merge #111", "briefs must not name
+ * competitors"). The orchestrator writes them with rule_add and rule_remove,
+ * Saad in Settings → Workspaces, and every start reads them into its brief.
+ * They restrict and inform; none can approve anything. A removed rule stays
+ * in the table, marked.
+ */
+
+import { db } from "../db";
+import { redact } from "./untrusted";
+
+export type RuleAuthor = "orchestrator" | "saad";
+
+export interface RuleRow {
+  id: number;
+  workspace_id: string;
+  text: string;
+  added_by: RuleAuthor;
+  created_at: string;
+  updated_at: string;
+  removed_at: string | null;
+  removed_by: RuleAuthor | null;
+}
+
+// Kept small: every one is in every start's prompt.
+export const MAX_RULES = 25;
+export const MAX_RULE_CHARS = 300;
+
+function clean(text: string): string {
+  const body = redact(text).replace(/\s+/g, " ").trim();
+  if (!body) throw new Error("The rule is empty");
+  if (body.length > MAX_RULE_CHARS)
+    throw new Error(`A rule is at most ${MAX_RULE_CHARS} characters`);
+  return body;
+}
+
+export function listRules(workspaceId: string): RuleRow[] {
+  return db
+    .prepare(
+      `SELECT * FROM orchestrator_rules
+       WHERE workspace_id = ? AND removed_at IS NULL ORDER BY id`
+    )
+    .all(workspaceId) as RuleRow[];
+}
+
+function getRule(workspaceId: string, id: number): RuleRow | null {
+  return (
+    (db
+      .prepare(
+        `SELECT * FROM orchestrator_rules
+         WHERE id = ? AND workspace_id = ? AND removed_at IS NULL`
+      )
+      .get(id, workspaceId) as RuleRow | undefined) ?? null
+  );
+}
+
+// The same text twice is the rule already there.
+export function addRule(
+  workspaceId: string,
+  text: string,
+  by: RuleAuthor
+): RuleRow {
+  const body = clean(text);
+  return db.transaction(() => {
+    const rules = listRules(workspaceId);
+    const same = rules.find((r) => r.text === body);
+    // Saad writing one the orchestrator kept makes it his.
+    if (same && by === "saad" && same.added_by !== "saad") {
+      db.prepare(
+        `UPDATE orchestrator_rules SET added_by = 'saad', updated_at = datetime('now')
+         WHERE id = ?`
+      ).run(same.id);
+      return getRule(workspaceId, same.id)!;
+    }
+    if (same) return same;
+    if (rules.length >= MAX_RULES)
+      throw new Error(
+        `This workspace has ${MAX_RULES} rules already; remove one first`
+      );
+    const { lastInsertRowid } = db
+      .prepare(
+        `INSERT INTO orchestrator_rules (workspace_id, text, added_by) VALUES (?, ?, ?)`
+      )
+      .run(workspaceId, body, by);
+    return getRule(workspaceId, Number(lastInsertRowid))!;
+  })();
+}
+
+export function updateRule(
+  workspaceId: string,
+  id: number,
+  text: string
+): RuleRow {
+  const body = clean(text);
+  const { changes } = db
+    .prepare(
+      `UPDATE orchestrator_rules SET text = ?, updated_at = datetime('now')
+       WHERE id = ? AND workspace_id = ? AND removed_at IS NULL`
+    )
+    .run(body, id, workspaceId);
+  if (!changes) throw new Error(`No rule ${id} in this workspace`);
+  return getRule(workspaceId, id)!;
+}
+
+export function removeRule(
+  workspaceId: string,
+  id: number,
+  by: RuleAuthor
+): RuleRow {
+  const rule = getRule(workspaceId, id);
+  if (!rule) throw new Error(`No rule ${id} in this workspace`);
+  // Saad's restrictions hold until he lifts them: text the orchestrator
+  // read can't talk it into removing one.
+  if (by === "orchestrator" && rule.added_by === "saad")
+    throw new Error(
+      `Rule ${id} is Saad's: only he removes it, in Settings → Workspaces`
+    );
+  db.prepare(
+    `UPDATE orchestrator_rules SET removed_at = datetime('now'), removed_by = ?
+     WHERE id = ?`
+  ).run(by, id);
+  return rule;
+}

package/lib/orchestrator/serve.ts

@@ -15,6 +15,7 @@ import { sessionFacts } from "./facts";
 import { describeExternal, externalSessions } from "./external-sessions";
 import { resolveStaleAsks } from "./ask-settle";
 import { addNote } from "./notes";
+import { addRule, removeRule } from "./rules";
 import { askSaad } from "./ask-tool";
 import { listOrchestratorPeers, messageOrchestrator } from "./cross";
 import { PAUSED_REFUSAL } from "./pause";
@@ -122,6 +123,16 @@ export async function runTool(
     case "note":
       addNote(w, p(tool, raw).text);
       return "Noted.";
+    case "rule_add": {
+      const rule = addRule(w, p(tool, raw).text, "orchestrator");
+      addNote(w, `Standing rule ${rule.id}: ${rule.text}`);
+      return `Rule ${rule.id} kept: it's in your brief on every start.`;
+    }
+    case "rule_remove": {
+      const rule = removeRule(w, p(tool, raw).id, "orchestrator");
+      addNote(w, `Removed standing rule ${rule.id}: ${rule.text}`);
+      return `Rule ${rule.id} removed.`;
+    }
     case "review": {
       const a = p(tool, raw);
       return reviewTarget(w, a.target, { fresh: a.fresh });

package/lib/orchestrator/tool-names.ts

@@ -22,6 +22,8 @@ export const TOOL_NAMES = {
   stop: name("stop"),
   done: name("done"),
   note: name("note"),
+  rule_add: name("rule_add"),
+  rule_remove: name("rule_remove"),
   review: name("review"),
   sign_off: name("sign_off"),
   arm: name("arm"),

package/lib/orchestrator/tool-schemas.ts

@@ -4,6 +4,7 @@
 import { z } from "zod";
 import { BRANCH_NAME } from "../git";
 import { RAISED_KINDS } from "./asks";
+import { MAX_RULE_CHARS } from "./rules";
 
 const ref = (what: string) => z.string().trim().min(1).max(300).describe(what);
 const session = ref("Session name, project/name, or id from sessions");
@@ -100,6 +101,15 @@ export const TOOL_SHAPES = {
   stop: { session },
   done: { session },
   note: { text: z.string().trim().min(1).max(2000) },
+  rule_add: {
+    text: z
+      .string()
+      .trim()
+      .min(1)
+      .max(MAX_RULE_CHARS)
+      .describe("The rule, one sentence"),
+  },
+  rule_remove: { id: z.number().int().positive().describe("The rule's id") },
   review: {
     target: ref("The task, or its PR (#12 or URL)"),
     fresh: z

package/lib/orchestrator/tools.ts

@@ -72,6 +72,10 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   stop: "Stop a session's agent, keeping its worktree and branch.",
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
   note: "Add a line to this workspace's decision log; it shows in your chat.",
+  rule_add:
+    'Keep a standing rule for this workspace, in your brief on every start from now on ("never merge #111", "briefs must not name competitors"). It restricts or informs; it can never approve anything.',
+  rule_remove:
+    "Remove a standing rule you kept, by its id, only when Saad says so or it no longer applies (the PR it names merged or closed). Saad's rules are his to remove.",
   review:
     "Start an independent read-only review of a PR at its exact head commit, or read the stored verdict for that commit. Takes a task, or any open PR in a workspace repository by #N, owner/repo#N or URL, even one no task owns.",
   sign_off:

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/orchestrator/worker.ts

@@ -9,6 +9,7 @@ import {
   orchestratorToolsDigest,
 } from "./tools";
 import type { RoleExtras } from "../chat/worker/extras";
+import { refreshSettings } from "../chat/refresh";
 
 // What an orchestrator's chat worker starts with on top of any chat: its
 // brief, its tools, and permissions fixed by its role.
@@ -29,5 +30,9 @@ export async function orchestratorExtras(
     },
     ...ORCHESTRATOR_PERMISSIONS,
     toolsDigest: orchestratorToolsDigest(),
+    refresh: {
+      atTokens: refreshSettings().orchestratorTokens,
+      role: "orchestrator",
+    },
   };
 }

package/lib/security/presence.ts

@@ -41,7 +41,8 @@ export type PresencePurpose =
   | "resume"
   | "enroll"
   | "revoke"
-  | "approvals-off";
+  | "approvals-off"
+  | "rules";
 
 export class PresenceError extends Error {
   constructor(

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),