@saadnvd1/agent-os 0.3.474 → 0.3.477

package/lib/away/run.ts

@@ -18,7 +18,6 @@ import { holdingEscalations } from "../orchestrator/gates";
 import { review } from "../orchestrator/review";
 import { repoOf } from "../orchestrator/repo";
 import { clip } from "../orchestrator/digest";
-import { sendMessage } from "../bus";
 import { notifyPhone } from "../notify";
 import { getProject } from "../projects";
 import { loadProjectConfig } from "../project-config";
@@ -29,6 +28,8 @@ import { auditId, auditsRoot, writeAtomic } from "../session-audit/store";
 import {
   activeAway,
   claimSweep,
+  reachedWorkspaces,
+  toldKey,
   endAway,
   fromSql,
   isExpired,
@@ -44,6 +45,7 @@ import {
   SWEEP_EVERY_MS,
   type Candidate,
 } from "./sweep";
+import { agentLive, awayWindowMs, lastTurnAt } from "./activity";
 import { checkDeploy } from "./deploy";
 import { buildAwayReport, phoneSummary, reportMarkdown } from "./report";
 import { awayOnLine } from "./brief";
@@ -59,9 +61,61 @@ function orchestrated(): { workspaceId: string; orchestratorId: string }[] {
     .map((o) => ({ workspaceId: o.workspace_id!, orchestratorId: o.id }));
 }
 
-function tellOrchestrators(key: string, line: string, now: number): void {
-  for (const { workspaceId } of orchestrated())
-    queueEvent(workspaceId, key, null, line, now);
+const sessionRow = (id: string) =>
+  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+
+// Away mode reaches a workspace only through an orchestrator that's been
+// working inside the window: one left alone isn't told or woken.
+export function orchestratorActive(
+  orchestratorId: string,
+  now = Date.now()
+): boolean {
+  const s = sessionRow(orchestratorId);
+  if (!s) return false;
+  const turn = lastTurnAt(s);
+  return turn > 0 && now - turn <= awayWindowMs();
+}
+
+// Tells an active orchestrator Saad is away: once a period, or again when
+// `resend` (the end moved). False when it isn't active (now), so it's
+// left alone.
+function tellAway(
+  away: AwayRow,
+  workspaceId: string,
+  orchestratorId: string,
+  now: number,
+  resend = false
+): boolean {
+  // Checked every time: a digest's own turn isn't activity, so Away can't
+  // keep an orchestrator going that nothing else has.
+  if (!orchestratorActive(orchestratorId, now)) return false;
+  const told = reachedWorkspaces(away.id).has(workspaceId);
+  // One transaction: a crash can't leave the marker set with the event
+  // never queued.
+  db.transaction(() => {
+    if (!told) {
+      db.prepare(
+        `INSERT OR IGNORE INTO away_actions (away_id, workspace_id, subject, kind, key)
+         VALUES (?, ?, ?, 'told', ?)`
+      ).run(away.id, workspaceId, orchestratorId, toldKey(workspaceId));
+      addNote(
+        workspaceId,
+        `Saad turned Away on, ${untilText(away, now)}.`,
+        "away"
+      );
+    }
+    if (!told || resend)
+      queueEvent(
+        workspaceId,
+        `away:${away.id}`,
+        null,
+        awayOnLine(away, now),
+        now
+      );
+  })();
+  return true;
 }
 
 // In Settings > Audits under "away", named for when it ended (local time)
@@ -79,14 +133,8 @@ export function turnAwayOn(
 ): AwayRow {
   const { row, started } = startAway(input, now);
   // Sent again when the end moves, so the orchestrator has the new one.
-  tellOrchestrators(`away:${row.id}`, awayOnLine(row, now), now);
-  if (started)
-    for (const { workspaceId } of orchestrated())
-      addNote(
-        workspaceId,
-        `Saad turned Away on, ${untilText(row, now)}.`,
-        "away"
-      );
+  for (const { workspaceId, orchestratorId } of orchestrated())
+    tellAway(row, workspaceId, orchestratorId, now, !started);
   return row;
 }
 
@@ -101,7 +149,11 @@ export function turnAwayOff(
   const done = db.transaction(() => {
     const row = endAway(by, now);
     if (!row) return null;
-    const report = buildAwayReport(row, deployConfigured);
+    const report = buildAwayReport(
+      row,
+      deployConfigured,
+      reachedWorkspaces(row.id)
+    );
     saveReport(row.id, report);
     return { ended: row, report };
   })();
@@ -116,13 +168,14 @@ export function turnAwayOff(
     by === "expired"
       ? "Away mode ran out: Saad may be back. Go back to reacting to events; don't drive interactive sessions."
       : "Saad is back: Away mode is off. Go back to reacting to events.";
-  tellOrchestrators(`back:${ended.id}`, line, now);
-  for (const { workspaceId } of orchestrated())
+  for (const workspaceId of reachedWorkspaces(ended.id)) {
+    queueEvent(workspaceId, `away-back:${ended.id}`, null, line, now);
     addNote(
       workspaceId,
       by === "expired" ? "Away ran out." : "Saad turned Away off.",
       "away"
     );
+  }
   // What came up since the last sweep's batch (a held `aos notify` is in
   // no report), then the summary. A second later, so the window takes
   // everything up to now.
@@ -175,21 +228,6 @@ function actedKeys(awayId: number, workspaceId: string): Set<string> {
   );
 }
 
-function nudgeCounts(awayId: number, workspaceId: string): Map<string, number> {
-  const rows = db
-    .prepare(
-      `SELECT subject, COUNT(*) AS n FROM away_actions
-       WHERE away_id = ? AND workspace_id = ? AND kind = 'nudge' GROUP BY subject`
-    )
-    .all(awayId, workspaceId) as { subject: string; n: number }[];
-  return new Map(rows.map((r) => [r.subject, r.n]));
-}
-
-const sessionRow = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
-    | Session
-    | undefined;
-
 async function dirtySessions(ids: string[]): Promise<Set<string>> {
   const dirty = new Set<string>();
   // A few at a time: a burst of spawns is what loads the machine.
@@ -211,29 +249,19 @@ async function dirtySessions(ids: string[]): Promise<Set<string>> {
   return dirty;
 }
 
-async function act(
+// A lost review run again: a reviewer, never a message to the session.
+async function rerunReview(
   away: AwayRow,
   workspaceId: string,
-  orchestratorId: string,
   c: Candidate
-): Promise<void> {
-  if (!claim(away, workspaceId, c.sessionId, c.kind, c.key)) return;
+): Promise<string | null> {
+  if (!claim(away, workspaceId, c.sessionId, c.kind, c.key)) return null;
   try {
-    if (c.kind === "review") await review(workspaceId, c.sessionId);
-    else
-      await sendMessage({
-        fromId: orchestratorId,
-        to: c.sessionId,
-        body: c.message!,
-      });
-    addNote(workspaceId, `Away sweep: ${c.log}`, "away");
+    await review(workspaceId, c.sessionId);
+    return c.line;
   } catch (error) {
     const why = error instanceof Error ? error.message : String(error);
-    addNote(
-      workspaceId,
-      `Away sweep: ${c.log} It didn't go through: ${clip(why, 200)}`,
-      "away"
-    );
+    return `${c.line.replace(/; AgentOS ran it again\.$/, "")}; running it again failed: ${clip(why, 200)}`;
   }
 }
 
@@ -257,12 +285,26 @@ async function mergeCommit(repo: string, pr: number): Promise<string | null> {
   return SHA.test(sha) ? sha : null;
 }
 
-// Each task merged while away, until its deploy is decided.
+// Each task merged while away, until its deploy is decided. Returns the
+// digest's line for each one decided now.
+// Claimed with the digest that reports it, so a crash in between can't
+// leave a deploy marked as reported that never was.
+class EmptyDigest extends Error {}
+
+interface DeployFinding {
+  subject: string;
+  kind: string;
+  key: string;
+  detail: string;
+  line: string;
+}
+
 async function checkDeploys(
   away: AwayRow,
   workspaceId: string,
   now: number
-): Promise<void> {
+): Promise<DeployFinding[]> {
+  const found: DeployFinding[] = [];
   const merged = db
     .prepare(
       `SELECT s.* FROM sessions s JOIN projects p ON p.id = s.project_id
@@ -294,27 +336,55 @@ async function checkDeploys(
         : verdict.state === "failed"
           ? "deploy_failed"
           : "deploy_unchecked";
-    if (!claim(away, workspaceId, s.id, kind, `deploy:${s.id}`, verdict.detail))
+    const key = `deploy:${s.id}`;
+    if (verdict.state === "unchecked") {
+      claim(away, workspaceId, s.id, kind, key, verdict.detail);
       continue;
-    if (verdict.state === "unchecked") continue;
-    const line = `task ${s.name}: PR #${s.pr_number ?? "?"} merged; ${verdict.state === "ok" ? verdict.detail : `deploy failed: ${verdict.detail}`}`;
-    addNote(workspaceId, `Away sweep: ${line}`, "away");
-    if (verdict.state === "failed")
-      queueEvent(workspaceId, `deploy:${s.id}`, s.id, line, now);
+    }
+    found.push({
+      subject: s.id,
+      kind,
+      key,
+      detail: verdict.detail,
+      line: `task ${s.name}: PR #${s.pr_number ?? "?"} merged; ${verdict.state === "ok" ? verdict.detail : `deploy failed: ${verdict.detail}`}`,
+    });
   }
+  return found;
 }
 
+const DIGEST_HEAD =
+  "Away sweep: what changed in this workspace since the last digest. Sessions not listed had no real activity inside the window or nothing new; leave them alone.";
+
+const candidateLabel: Record<Candidate["kind"], string> = {
+  stalled: "stalled",
+  commit: "uncommitted, no PR",
+  review: "review",
+  wrapup: "interactive",
+};
+
+// Sweeps a workspace whose orchestrator is active: lost reviews run again,
+// deploys checked, and what's new goes to the orchestrator as one digest
+// event. No other session is ever messaged. Returns the digest, if one went.
 export async function sweepWorkspace(
   away: AwayRow,
   workspaceId: string,
   orchestratorId: string,
   now = Date.now()
-): Promise<void> {
+): Promise<string | null> {
   // Paused means it acts on nothing, the sweep included.
-  if (isPaused(workspaceId)) return;
+  if (isPaused(workspaceId)) return null;
+  if (!tellAway(away, workspaceId, orchestratorId, now)) return null;
   const facts = await sessionFacts(workspaceId);
   const acted = actedKeys(away.id, workspaceId);
-  const dirty = await dirtySessions(needsGitCheck(facts, now, acted));
+  const rows = new Map(
+    facts.map((f) => [f.id, sessionRow(f.id)] as const).filter(([, s]) => s)
+  ) as Map<string, Session>;
+  const turns = new Map([...rows].map(([id, s]) => [id, lastTurnAt(s)]));
+  const live = new Set(
+    facts
+      .filter((f) => !f.task && rows.has(f.id) && agentLive(rows.get(f.id)!))
+      .map((f) => f.id)
+  );
   const openOn = new Set(
     (
       db
@@ -329,13 +399,19 @@ export async function sweepWorkspace(
       .filter((f) => openOn.has(f.id) || holdingEscalations(f.id).length)
       .map((f) => f.id)
   );
-  const { act: todo, firstSeen } = pickCandidates({
+  const windowMs = awayWindowMs();
+  const dirty = await dirtySessions(
+    needsGitCheck({ facts, now, turns, windowMs, live, held, acted })
+  );
+  const { flags, reviews, firstSeen } = pickCandidates({
     now,
     facts,
+    turns,
+    windowMs,
+    live,
     dirty,
     held,
     acted,
-    nudges: nudgeCounts(away.id, workspaceId),
     reviewOf: (id, sha) => {
       const c = getCheck(id, sha, "review");
       return c ? { status: c.status, at: fromSql(c.created_at) } : null;
@@ -343,8 +419,50 @@ export async function sweepWorkspace(
   });
   for (const key of firstSeen)
     claim(away, workspaceId, key.split(":")[1], "seen", key);
-  for (const c of todo) await act(away, workspaceId, orchestratorId, c);
-  await checkDeploys(away, workspaceId, now);
+  const lines: string[] = [];
+  for (const c of reviews) {
+    const line = await rerunReview(away, workspaceId, c);
+    if (line) lines.push(`- review: ${line}`);
+  }
+  const deploys = await checkDeploys(away, workspaceId, now);
+  if (!flags.length && !deploys.length && !lines.length) return null;
+  // Claimed like the rest, so a period's digests are counted and a sweep
+  // that ended meanwhile sends none. The digest, its event and the
+  // candidates it reports commit together.
+  const send = db.transaction((): string => {
+    if (
+      !claim(
+        away,
+        workspaceId,
+        orchestratorId,
+        "digest",
+        `digest:${workspaceId}:${now}`
+      )
+    )
+      throw new EmptyDigest();
+    const items = [...lines];
+    for (const c of flags)
+      if (claim(away, workspaceId, c.sessionId, c.kind, c.key))
+        items.push(`- ${candidateLabel[c.kind]}: ${c.line}`);
+    for (const d of deploys)
+      if (claim(away, workspaceId, d.subject, d.kind, d.key, d.detail))
+        items.push(`- deploy: ${d.line}`);
+    if (!items.length) throw new EmptyDigest();
+    const text = [DIGEST_HEAD, ...items].join("\n");
+    queueEvent(workspaceId, `away-digest:${away.id}:${now}`, null, text, now);
+    addNote(
+      workspaceId,
+      `Away sweep: sent the orchestrator a digest of ${items.length} ${items.length === 1 ? "item" : "items"}.`,
+      "away"
+    );
+    return text;
+  });
+  try {
+    return send();
+  } catch (e) {
+    if (e instanceof EmptyDigest) return null;
+    throw e;
+  }
 }
 
 // One phone message for what came up since the last: new asks across

package/lib/away/state.ts

@@ -48,6 +48,23 @@ export function getAway(id: number): AwayRow | null {
   );
 }
 
+// The away_actions row marking a workspace Away mode reached this period:
+// its orchestrator was active and was told (./run). Keys are unique per
+// period, so it names the workspace.
+export const toldKey = (workspaceId: string) => `told:${workspaceId}`;
+
+export function reachedWorkspaces(awayId: number): Set<string> {
+  return new Set(
+    (
+      db
+        .prepare(
+          `SELECT workspace_id FROM away_actions WHERE away_id = ? AND kind = 'told'`
+        )
+        .all(awayId) as { workspace_id: string }[]
+    ).map((r) => r.workspace_id)
+  );
+}
+
 export const isExpired = (row: AwayRow, now = Date.now()) =>
   !!row.expires_at && fromSql(row.expires_at) <= now;
 

package/lib/away/sweep.ts

@@ -1,17 +1,22 @@
 /**
  * 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.
+ * (session facts, real activity, 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.
+ * The sweep messages no session. What it finds goes to the workspace's
+ * orchestrator as one digest, which decides what needs doing:
+ * - a task with no real activity for STALL_MS and nothing to wait on;
+ * - a task idle with uncommitted work and no PR;
+ * - an interactive session (Saad's) idle with uncommitted work, whose
+ *   agent is still up: the orchestrator may ask it once to wrap up.
+ * Only sessions with a real turn inside the window are listed; older ones
+ * are left alone. Each is listed once per state (per period, for an
+ * interactive one).
+ *
+ * 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. That
+ * runs a reviewer, not the session, so it isn't held to the window.
  */
 
 import { isFinished } from "../tasks/state";
@@ -20,21 +25,18 @@ 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 type CandidateKind = "stalled" | "commit" | "review" | "wrapup";
 
 export interface Candidate {
   kind: CandidateKind;
   sessionId: string;
-  // Acted on once per Away period.
+  // Listed (or run, for a review) 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;
+  // Its line in the orchestrator's digest and the decision log.
+  line: string;
 }
 
 export interface ReviewSeen {
@@ -45,6 +47,12 @@ export interface ReviewSeen {
 export interface SweepView {
   now: number;
   facts: SessionFacts[];
+  // Each session's last real turn, in ms (./activity).
+  turns: ReadonlyMap<string, number>;
+  // Older than this is left alone.
+  windowMs: number;
+  // Interactive sessions whose agent is up.
+  live: ReadonlySet<string>;
   // Sessions with uncommitted changes in their worktree.
   dirty: ReadonlySet<string>;
   // The stored review verdict of a session's commit, if any.
@@ -53,17 +61,24 @@ export interface SweepView {
   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.";
+const turnOf = (f: SessionFacts, v: Pick<SweepView, "turns">) =>
+  v.turns.get(f.id) ?? 0;
+
+// Real activity inside the window: anything older is never listed.
+export const recent = (
+  f: SessionFacts,
+  v: Pick<SweepView, "now" | "turns" | "windowMs">
+) => {
+  const turn = turnOf(f, v);
+  return turn > 0 && v.now - turn <= v.windowMs;
+};
 
-// Live work with an agent to answer: not finished, not a linked machine's
-// copy, not setting up, not waiting on someone already.
+// Live work with an agent to answer: not stopped, 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;
@@ -79,62 +94,63 @@ function workable(f: SessionFacts): boolean {
   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
+const commitKey = (f: SessionFacts, turn: number) => `commit:${f.id}:${turn}`;
+const wrapupKey = (f: SessionFacts) => `wrapup:${f.id}`;
+export const seenKey = (id: string, sha: string) => `review-seen:${id}:${sha}`;
+
+// Who could be listed at all.
+function eligible(f: SessionFacts, v: GitView): boolean {
+  if (!workable(f) || !recent(f, v)) return false;
+  return f.task ? !v.held.has(f.id) : v.live.has(f.id);
+}
+
+type GitView = Pick<
+  SweepView,
+  "facts" | "now" | "turns" | "windowMs" | "live" | "held" | "acted"
+>;
+
+// Sessions worth a `git status`: recent, quiet long enough that
+// uncommitted work would matter, and not already listed for it. Keeps the
 // sweep from reading every worktree.
-export function needsGitCheck(
-  facts: SessionFacts[],
-  now: number,
-  acted: ReadonlySet<string>
-): string[] {
-  return facts
+export function needsGitCheck(v: GitView): string[] {
+  return v.facts
     .filter(
       (f) =>
-        workable(f) &&
+        eligible(f, v) &&
         f.status === "idle" &&
         !f.task?.pr &&
-        now - f.lastActive >= IDLE_DIRTY_MS &&
-        !acted.has(f.task ? commitKey(f) : wrapupKey(f))
+        v.now - turnOf(f, v) >= IDLE_DIRTY_MS &&
+        !v.acted.has(f.task ? commitKey(f, turnOf(f, v)) : 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 pr = f.task!.pr;
+  const turn = turnOf(f, v);
+  const quiet = v.now - turn;
   const who = `task ${f.name}`;
 
   if (!pr && f.status === "idle" && v.dirty.has(f.id)) {
-    const key = commitKey(f);
+    const key = commitKey(f, turn);
     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.`,
+      line: `${who} (${f.id}): idle ${minutes(quiet)}m with uncommitted work and no PR.`,
     };
   }
 
   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}`;
+    const key = `stalled:${f.id}:${turn}`;
     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",
+      kind: "stalled",
       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.`,
+      line: `${who} (${f.id}): no activity for ${minutes(quiet)}m${ciFailing ? `, CI failing on PR #${pr!.number}` : ", no PR yet"}.`,
     };
   }
   return null;
@@ -169,7 +185,7 @@ function reviewCandidate(f: SessionFacts, v: SweepView): Candidate | null {
     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.`,
+    line: `task ${f.name}: the review of PR #${pr.number} at ${pr.head.slice(0, 7)} was ${why}; AgentOS ran it again.`,
   };
 }
 
@@ -181,36 +197,34 @@ function wrapupCandidate(f: SessionFacts, v: SweepView): Candidate | null {
     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.`,
+    line: `${f.name} (${f.id}): Saad's own session, idle ${minutes(v.now - turnOf(f, v))}m with uncommitted work.`,
   };
 }
 
-// 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`).
+// What's new this sweep: lines for the orchestrator's digest, and the
+// reviews to run again. A review candidate seen for the first time is
+// returned only once its seen-key is in `acted`; the caller records the
+// seen-key otherwise (`firstSeen`).
 export function pickCandidates(v: SweepView): {
-  act: Candidate[];
+  flags: Candidate[];
+  reviews: Candidate[];
   firstSeen: string[];
 } {
-  const act: Candidate[] = [];
+  const flags: Candidate[] = [];
+  const reviews: 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);
+        if (v.acted.has(seen)) reviews.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);
     }
+    if (!eligible(f, v)) continue;
+    const c = f.task ? taskCandidate(f, v) : wrapupCandidate(f, v);
+    if (c) flags.push(c);
   }
-  return { act, firstSeen };
+  return { flags, reviews, firstSeen };
 }

package/lib/away/window-limits.ts

@@ -0,0 +1,16 @@
+// The Away window's bounds, in minutes, for the server (./activity) and
+// the Settings form alike. Client-safe: no database.
+export const DEFAULT_WINDOW_MINUTES = 60;
+export const MIN_WINDOW_MINUTES = 10;
+export const MAX_WINDOW_MINUTES = 24 * 60;
+
+// The form's text as minutes, or null when it's out of bounds.
+export function parseWindow(text: string): number | null {
+  const n = Number(text.trim());
+  return text.trim() &&
+    Number.isInteger(n) &&
+    n >= MIN_WINDOW_MINUTES &&
+    n <= MAX_WINDOW_MINUTES
+    ? n
+    : null;
+}

package/lib/chat/events.ts

@@ -80,6 +80,9 @@ export interface ChatOrigin {
   body?: string;
   // Lines of an event batch that are the reader's answers to asks.
   decided?: string[];
+  // Only Away mode's own lines: the turn it starts isn't anyone's activity
+  // (lib/away/activity).
+  away?: true;
 }
 
 // Who sent a message, carried with it through the queue and the worker.