@saadnvd1/agent-os 0.3.459 → 0.3.461

package/lib/away/sweep.ts

@@ -0,0 +1,216 @@
+/**
+ * The away sweep's choices, made by code from what the server already knows
+ * (session facts, git status, stored review verdicts), never by a model
+ * reading the workspace. Pure: ./run gathers the inputs and acts.
+ *
+ * - A task with no activity for STALL_MS and nothing to wait on is nudged,
+ *   at most MAX_NUDGES times a period, and again only after it moved.
+ * - A task idle with uncommitted work and no PR is asked to commit and open
+ *   one, or say why not.
+ * - A PR whose CI settled green with no review of its head, or one that was
+ *   lost (errored, or cut off and stale), has its review run again, once
+ *   the sweep has seen it that way twice, so the orchestrator had its turn.
+ * - An interactive session is Saad's: one with uncommitted work is asked to
+ *   wrap up, once a period, and nothing more.
+ */
+
+import { isFinished } from "../tasks/state";
+import type { SessionFacts } from "../orchestrator/facts";
+
+export const SWEEP_EVERY_MS = 10 * 60 * 1000;
+export const STALL_MS = 30 * 60 * 1000;
+export const IDLE_DIRTY_MS = 15 * 60 * 1000;
+export const MAX_NUDGES = 2;
+// A review "running" this long was cut off (as clearStaleRunning has it).
+export const STALE_REVIEW_MS = 30 * 60 * 1000;
+
+export type CandidateKind = "nudge" | "commit" | "review" | "wrapup";
+
+export interface Candidate {
+  kind: CandidateKind;
+  sessionId: string;
+  // Acted on once per Away period.
+  key: string;
+  // What the session is told (none for a review).
+  message?: string;
+  // One line for the decision log.
+  log: string;
+}
+
+export interface ReviewSeen {
+  status: "running" | "pass" | "block" | "error";
+  at: number;
+}
+
+export interface SweepView {
+  now: number;
+  facts: SessionFacts[];
+  // Sessions with uncommitted changes in their worktree.
+  dirty: ReadonlySet<string>;
+  // The stored review verdict of a session's commit, if any.
+  reviewOf: (sessionId: string, sha: string) => ReviewSeen | null;
+  // Tasks that are Saad's now: escalated, or an open ask on them.
+  held: ReadonlySet<string>;
+  // Keys acted on (or seen, for reviews) this period.
+  acted: ReadonlySet<string>;
+  // Nudges sent to each session this period.
+  nudges: ReadonlyMap<string, number>;
+}
+
+const minutes = (ms: number) => Math.floor(ms / 60000);
+
+const BLOCKED_HINT =
+  "If only Saad can unblock it, end with a line starting BLOCKED: that says what you need.";
+
+// Live work with an agent to answer: not finished, not a linked machine's
+// copy, not setting up, not waiting on someone already.
+function workable(f: SessionFacts): boolean {
+  if (f.status === "dead" || f.status === "waiting" || f.needsInput)
+    return false;
+  if (f.activity === "setting up") return false;
+  if (
+    f.task &&
+    (isFinished(f.task.state) ||
+      f.task.state === "moving" ||
+      f.task.state === "exited" ||
+      f.task.blocked !== null)
+  )
+    return false;
+  return true;
+}
+
+// Sessions worth a `git status`: quiet long enough that uncommitted work
+// would matter, and not already asked about it this period. Keeps the
+// sweep from reading every worktree.
+export function needsGitCheck(
+  facts: SessionFacts[],
+  now: number,
+  acted: ReadonlySet<string>
+): string[] {
+  return facts
+    .filter(
+      (f) =>
+        workable(f) &&
+        f.status === "idle" &&
+        !f.task?.pr &&
+        now - f.lastActive >= IDLE_DIRTY_MS &&
+        !acted.has(f.task ? commitKey(f) : wrapupKey(f))
+    )
+    .map((f) => f.id);
+}
+
+const commitKey = (f: SessionFacts) => `commit:${f.id}:${f.lastActive}`;
+const wrapupKey = (f: SessionFacts) => `wrapup:${f.id}`;
+export const seenKey = (id: string, sha: string) => `review-seen:${id}:${sha}`;
+
+function taskCandidate(f: SessionFacts, v: SweepView): Candidate | null {
+  const task = f.task!;
+  const pr = task.pr;
+  const quiet = v.now - f.lastActive;
+  const who = `task ${f.name}`;
+
+  if (!pr && f.status === "idle" && v.dirty.has(f.id)) {
+    const key = commitKey(f);
+    if (v.acted.has(key)) return null;
+    return {
+      kind: "commit",
+      sessionId: f.id,
+      key,
+      message: `Saad is away. You've been idle ${minutes(quiet)} minutes with uncommitted work and no pull request. Commit it and open a pull request, as your task says. If it shouldn't be one, end with a line starting BLOCKED: that says why not.`,
+      log: `${who}: idle ${minutes(quiet)}m with uncommitted work and no PR; asked it to commit and open one, or say why not.`,
+    };
+  }
+
+  const ciFailing = pr?.state === "OPEN" && pr.checks === "fail";
+  if ((!pr || ciFailing) && quiet >= STALL_MS) {
+    if ((v.nudges.get(f.id) ?? 0) >= MAX_NUDGES) return null;
+    const key = `nudge:${f.id}:${f.lastActive}`;
+    if (v.acted.has(key)) return null;
+    const what = ciFailing
+      ? `CI is failing on PR #${pr!.number}. Fix it and push.`
+      : "Carry the task on to a pull request.";
+    return {
+      kind: "nudge",
+      sessionId: f.id,
+      key,
+      message: `Saad is away, and AgentOS hasn't seen activity from you in ${minutes(quiet)} minutes. ${what} ${BLOCKED_HINT}`,
+      log: `${who}: no activity for ${minutes(quiet)}m${ciFailing ? ` with CI failing on PR #${pr!.number}` : ", no PR"}; nudged it.`,
+    };
+  }
+  return null;
+}
+
+function reviewCandidate(f: SessionFacts, v: SweepView): Candidate | null {
+  const pr = f.task?.pr;
+  if (
+    !f.task ||
+    isFinished(f.task.state) ||
+    pr?.state !== "OPEN" ||
+    !pr.head ||
+    pr.checks !== "pass" ||
+    (f.task.ciSettleIn ?? 0) > 0 ||
+    v.held.has(f.id)
+  )
+    return null;
+  const seen = v.reviewOf(f.id, pr.head);
+  const lost =
+    !seen ||
+    seen.status === "error" ||
+    (seen.status === "running" && v.now - seen.at >= STALE_REVIEW_MS);
+  if (!lost) return null;
+  const key = `review:${f.id}:${pr.head}`;
+  if (v.acted.has(key)) return null;
+  const why = !seen
+    ? "never started"
+    : seen.status === "error"
+      ? "lost (it errored)"
+      : "lost (cut off)";
+  return {
+    kind: "review",
+    sessionId: f.id,
+    key,
+    log: `task ${f.name}: the review of PR #${pr.number} at ${pr.head.slice(0, 7)} was ${why}; ran it again.`,
+  };
+}
+
+function wrapupCandidate(f: SessionFacts, v: SweepView): Candidate | null {
+  if (f.status !== "idle" || !v.dirty.has(f.id)) return null;
+  const key = wrapupKey(f);
+  if (v.acted.has(key)) return null;
+  return {
+    kind: "wrapup",
+    sessionId: f.id,
+    key,
+    message:
+      "Saad is away. This session has uncommitted work. Wrap up: on a feature branch, commit what you have with a clear message; on the default branch, leave it uncommitted. Then stop and don't start anything new; Saad picks this up when he's back.",
+    log: `${f.name}: Saad's own session, idle with uncommitted work; asked it to wrap up.`,
+  };
+}
+
+// What to act on now. A review candidate seen for the first time is
+// returned with kind "review" only once its seen-key is in `acted`; the
+// caller records the seen-key otherwise (see `firstSeen`).
+export function pickCandidates(v: SweepView): {
+  act: Candidate[];
+  firstSeen: string[];
+} {
+  const act: Candidate[] = [];
+  const firstSeen: string[] = [];
+  for (const f of v.facts) {
+    if (f.task) {
+      const review = reviewCandidate(f, v);
+      if (review) {
+        const seen = seenKey(f.id, f.task.pr!.head!);
+        if (v.acted.has(seen)) act.push(review);
+        else firstSeen.push(seen);
+      }
+      if (!workable(f) || v.held.has(f.id)) continue;
+      const c = taskCandidate(f, v);
+      if (c) act.push(c);
+    } else if (workable(f)) {
+      const c = wrapupCandidate(f, v);
+      if (c) act.push(c);
+    }
+  }
+  return { act, firstSeen };
+}

package/lib/away/view.ts

@@ -0,0 +1,51 @@
+// What the browser gets: Away's state now, and the newest report Saad
+// hasn't dismissed. Times are ISO.
+
+import type { AwayReport } from "./report";
+import {
+  activeAway,
+  fromSql,
+  isExpired,
+  unseenReport,
+  type AwayRow,
+} from "./state";
+import { turnAwayOff } from "./run";
+
+export interface AwayView {
+  away: {
+    id: number;
+    setBy: string;
+    startedAt: string;
+    expiresAt: string | null;
+  } | null;
+  report: AwayReport | null;
+}
+
+const iso = (t: string) => new Date(fromSql(t)).toISOString();
+
+function reportOf(row: AwayRow | null): AwayReport | null {
+  if (!row?.report) return null;
+  try {
+    return JSON.parse(row.report) as AwayReport;
+  } catch {
+    return null;
+  }
+}
+
+export function awayView(now = Date.now()): AwayView {
+  let away = activeAway();
+  // The watcher ends it on time; this covers a server running without one.
+  if (away && isExpired(away, now)) {
+    turnAwayOff("expired", now);
+    away = null;
+  }
+  return {
+    away: away && {
+      id: away.id,
+      setBy: away.set_by,
+      startedAt: iso(away.started_at),
+      expiresAt: away.expires_at ? iso(away.expires_at) : null,
+    },
+    report: reportOf(unseenReport()),
+  };
+}

package/lib/chat/events.ts

@@ -192,7 +192,7 @@ export type ChatItem =
   | (Base & {
       kind: "note";
       text: string;
-      tone: "note" | "brake" | "escalation" | "ask" | "pause";
+      tone: "note" | "brake" | "escalation" | "ask" | "pause" | "away";
     })
   | (Base & {
       kind: "approval";

package/lib/db/changes.ts

@@ -27,11 +27,14 @@ export const TABLES_WATCHED_50 = ["task_queue"] as const;
 
 export const TABLES_WATCHED_56 = ["orchestrator_rules"] as const;
 
+export const TABLES_WATCHED_58 = ["away_periods"] as const;
+
 // Every table any migration watches, for the browser's topic map to cover.
 export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_45,
   ...TABLES_WATCHED_50,
   ...TABLES_WATCHED_56,
+  ...TABLES_WATCHED_58,
 ];
 
 export function installChangeTriggers(

package/lib/db/migrations.ts

@@ -3,6 +3,7 @@ import {
   TABLES_WATCHED_45,
   TABLES_WATCHED_50,
   TABLES_WATCHED_56,
+  TABLES_WATCHED_58,
 } from "./changes";
 import type Database from "better-sqlite3";
 
@@ -1226,6 +1227,106 @@ 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`
+        );
+    },
+  },
+  {
+    id: 58,
+    name: "away_mode",
+    up: (db) => {
+      // Saad's Away mode (lib/away): one row per time he stepped away. The
+      // report is built from the database when it ends and kept here.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS away_periods (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          set_by TEXT NOT NULL,
+          started_at TEXT NOT NULL DEFAULT (datetime('now')),
+          expires_at TEXT,
+          ended_at TEXT,
+          ended_by TEXT,
+          last_sweep_at TEXT,
+          asks_notified_at TEXT,
+          report TEXT,
+          report_seen_at TEXT
+        )
+      `);
+      // What the away sweep did, once per key per period: a nudge, a
+      // request to commit, a review run again, a deploy checked.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS away_actions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          away_id INTEGER NOT NULL,
+          workspace_id TEXT NOT NULL,
+          subject TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          key TEXT NOT NULL,
+          detail TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          UNIQUE (away_id, key)
+        )
+      `);
+      // When a task merged, whichever path merged it.
+      const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+        name: string;
+      }[];
+      if (!columns.some((c) => c.name === "merged_at"))
+        db.exec(`ALTER TABLE sessions ADD COLUMN merged_at TEXT`);
+      // When a task ended without a merge (dropped, or done with no PR or
+      // its PR closed).
+      if (!columns.some((c) => c.name === "task_ended_at"))
+        db.exec(`ALTER TABLE sessions ADD COLUMN task_ended_at TEXT`);
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS sessions_task_ended_at
+          AFTER UPDATE OF task_status ON sessions
+          WHEN NEW.task_status IN ('dropped', 'done')
+            AND OLD.task_status IS NOT NEW.task_status
+            AND NEW.task_ended_at IS OLD.task_ended_at
+        BEGIN
+          UPDATE sessions SET task_ended_at = datetime('now') WHERE id = NEW.id;
+        END
+      `);
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS sessions_merged_at
+          AFTER UPDATE OF task_status ON sessions
+          WHEN NEW.task_status = 'merged' AND OLD.task_status IS NOT 'merged'
+            -- unless the same statement set it (an import keeps its own)
+            AND NEW.merged_at IS OLD.merged_at
+        BEGIN
+          UPDATE sessions SET merged_at = datetime('now') WHERE id = NEW.id;
+        END
+      `);
+      installChangeTriggers(db, TABLES_WATCHED_58);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -87,6 +87,10 @@ export interface Session {
   pr_url: string | null;
   pr_number: number | null;
   pr_status: "open" | "merged" | "closed" | null;
+  // When task_status became merged (a trigger sets it, migration 58).
+  merged_at?: string | null;
+  // When it became dropped or done (migration 58).
+  task_ended_at?: string | null;
   // Merge as soon as every gate passes (orchestrator/armed.ts), and the
   // failure last reported while armed.
   merge_armed_at?: string | null;
@@ -97,6 +101,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 +210,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/notify/index.ts

@@ -7,6 +7,7 @@
 
 import { db, type Session } from "../db";
 import { Limiter, type Outcome } from "./limiter";
+import { holdForBatch, msToNextSweep } from "../away/state";
 import { selectNotifier, type TelegramConfig } from "./notifiers";
 
 export type { Outcome } from "./limiter";
@@ -135,6 +136,12 @@ export async function notifyFrom(
   if (from && !session) throw new Error("Unknown sender session");
   const body = text.trim();
   if (!body) throw new Error("Nothing to send");
+  if (
+    session?.role === "orchestrator" &&
+    session.workspace_id &&
+    holdForBatch(session.workspace_id, session.id, body)
+  )
+    return { state: "held", inMs: msToNextSweep() };
   return sendPhone(
     session ? `session:${session.id}` : "cli",
     session ? `${session.name}: ${body}` : body

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/digest.ts

@@ -12,6 +12,7 @@ import { openAsks } from "./asks";
 import { listRules } from "./rules";
 import { shortId } from "./describe";
 import { untrusted } from "./untrusted";
+import { awayDigestLine } from "../away/brief";
 
 // About four characters a token: close enough to cap a prompt.
 export const CHARS_PER_TOKEN = 4;
@@ -23,7 +24,7 @@ const EXTERNAL_DAYS = 2;
 
 // One line, cut to length. A cut that leaves a fence around another
 // session's text open closes it, so what follows isn't read as inside it.
-const clip = (text: string, cap = LINE_CAP) => {
+export const clip = (text: string, cap = LINE_CAP) => {
   const one = text.replace(/\s+/g, " ").trim();
   if (one.length <= cap) return one;
   const cut = `${one.slice(0, cap - 3)}...`;
@@ -53,21 +54,21 @@ interface TaskRow {
   armed_at: string | null;
 }
 
-interface CheckRow {
+export interface CheckRow {
   session_id: string;
   sha: string;
   kind: string;
   status: string;
 }
 
-interface FailureRow {
+export interface FailureRow {
   session_id: string;
   gate: string;
   count: number;
   escalated_at: string | null;
 }
 
-function checksBySession(workspaceId: string): Map<string, CheckRow[]> {
+export function checksBySession(workspaceId: string): Map<string, CheckRow[]> {
   // The newest verdict of each kind per session or PR.
   const rows = db
     .prepare(
@@ -85,7 +86,9 @@ function checksBySession(workspaceId: string): Map<string, CheckRow[]> {
   return by;
 }
 
-function failuresBySession(workspaceId: string): Map<string, FailureRow[]> {
+export function failuresBySession(
+  workspaceId: string
+): Map<string, FailureRow[]> {
   const rows = db
     .prepare(
       `SELECT session_id, gate, count, escalated_at FROM orchestrator_gate_failures
@@ -98,7 +101,7 @@ function failuresBySession(workspaceId: string): Map<string, FailureRow[]> {
   return by;
 }
 
-function gateState(
+export function gateState(
   checks: CheckRow[] = [],
   failures: FailureRow[] = []
 ): string {
@@ -321,8 +324,8 @@ export function buildDigest(
 ): string {
   const checks = checksBySession(workspaceId);
   const failures = failuresBySession(workspaceId);
-  const head =
-    "## Where things stand (read from AgentOS's database as you started)";
+  const away = awayDigestLine();
+  const head = `## Where things stand (read from AgentOS's database as you started)${away ? `\n\n${away}` : ""}`;
   const body = renderDigest(
     [
       rulesSection(workspaceId),

package/lib/orchestrator/notes.ts

@@ -10,7 +10,14 @@ import { saveItem } from "../chat/store";
 import type { ChatItem } from "../chat/events";
 import { getOrchestrator } from "./home";
 
-export type NoteKind = "note" | "brake" | "escalation" | "ask" | "pause";
+export type NoteKind =
+  | "note"
+  | "brake"
+  | "escalation"
+  | "ask"
+  | "pause"
+  // What Away mode's sweep did (lib/away).
+  | "away";
 
 export interface NoteRow {
   id: number;