@saadnvd1/agent-os 0.3.460 → 0.3.462

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";
 
@@ -1258,6 +1259,74 @@ const migrations: Migration[] = [
         );
     },
   },
+  {
+    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;

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/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;

package/lib/orchestrator/watcher.ts

@@ -18,6 +18,7 @@ import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
+import { awayTick } from "../away/run";
 
 // Asks that stopped needing Saad: their task or PR finished some other
 // way, or brakes lifted with nothing trying to start.
@@ -101,6 +102,11 @@ async function tick(): Promise<void> {
   if (busy) return;
   busy = true;
   try {
+    try {
+      awayTick();
+    } catch (error) {
+      console.error("Away mode:", error);
+    }
     for (const orch of listOrchestrators()) {
       const workspaceId = orch.workspace_id;
       if (!workspaceId || !getWorkspace(workspaceId)) continue;

package/lib/project-config/agentos.schema.json

@@ -73,6 +73,30 @@
       },
       "additionalProperties": false
     },
+    "deploy": {
+      "type": "object",
+      "properties": {
+        "deployed": {
+          "type": "string",
+          "minLength": 1
+        },
+        "failed": {
+          "type": "string",
+          "minLength": 1
+        },
+        "health": {
+          "type": "string",
+          "minLength": 1
+        },
+        "within_minutes": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 1440
+        }
+      },
+      "required": ["deployed"],
+      "additionalProperties": false
+    },
     "test": {
       "type": "string",
       "minLength": 1

package/lib/project-config/schema.ts

@@ -38,6 +38,22 @@ const ready = z.strictObject({
   contains: z.string().optional(),
 });
 
+// How Away mode checks a merge went live (lib/away/deploy.ts): a file the
+// deploy writes the deployed commit to, one it writes a commit whose deploy
+// failed to, and a URL that answers 2xx when the server is healthy (a path
+// alone is this AgentOS server's own).
+const deploy = z.strictObject({
+  deployed: z.string().min(1),
+  failed: z.string().min(1).optional(),
+  health: z.string().min(1).optional(),
+  within_minutes: z
+    .number()
+    .int()
+    .min(1)
+    .max(24 * 60)
+    .optional(),
+});
+
 const browse = z.strictObject({
   login: z.string().min(1).optional(),
   map: projectPath.optional(),
@@ -89,6 +105,7 @@ const shape = {
   clone: z.array(projectPath).optional(),
   dev: z.string().min(1).optional(),
   ready: ready.optional(),
+  deploy: deploy.optional(),
   test: z.string().min(1).optional(),
   notes: notes.optional(),
   browse: browse.optional(),

package/lib/worktree-hooks.ts

@@ -85,10 +85,19 @@ async function ownHooks(worktree: string): Promise<string> {
   return sh(path.join(common, "hooks"));
 }
 
+// Husky writes `.husky/_` on `npm install`, and it's gitignored, so a new
+// worktree has none and its hooks would silently not run: run the hook
+// script from `.husky/` the way husky's own runner does.
 const delegate = (own: string, hook: string) =>
   `root="$(git rev-parse --show-toplevel)"
 own=${own}/${hook}
 [ -x "$own" ] && exec "$own" "$@"
+case "$own" in
+*/.husky/_/${hook})
+  script="\${own%/_/${hook}}/${hook}"
+  [ -f "$script" ] && [ "\${HUSKY-}" != 0 ] && PATH="node_modules/.bin:$PATH" exec sh -e "$script" "$@"
+  ;;
+esac
 exit 0
 `;
 

package/package.json

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