@saadnvd1/agent-os 0.3.474 → 0.3.476

package/README.md

@@ -35,7 +35,7 @@ wait under **Queued** with their place in line and start on their own, and
 
 ### Each kind of work on the right model
 
-Planning and gate reviews run on Opus, implementation, the orchestrator and
+Planning, gate reviews and the orchestrator run on Opus, implementation and
 scope checks on Sonnet, titles and summaries on Haiku, each editable in
 Settings → Models and per workspace. A task plans on one model and
 implements on another in the same conversation, can be resumed on any
@@ -459,7 +459,7 @@ Each kind of work AgentOS launches an agent for runs on its own model, set in
 | Task planning (a task's plan step)                  | `anthropic/claude-opus-5-5`           |
 | Gate review                                         | `anthropic/claude-opus-5-5`           |
 | Task implementation                                 | `anthropic/claude-sonnet-5-5`         |
-| Orchestrator                                        | `anthropic/claude-sonnet-5-5`         |
+| Orchestrator                                        | `anthropic/claude-opus-5-5`           |
 | Scope check                                         | `anthropic/claude-sonnet-5-5`         |
 | Interactive sessions                                | `anthropic/claude-opus-5-5`           |
 | Chat & summary helpers (titles, summaries, PR text) | `anthropic/claude-haiku-4-5-20251001` |
@@ -1174,23 +1174,29 @@ reset` yourself in a terminal on the machine: it refuses inside an
   sidebar header or ⌘K ("Away for 4 hours"), for 1 hour, 4 hours, until
   morning (8 AM) or until you're back. It's kept in `away_periods` (who set
   it, when, when it ends), the cup turns amber while it's on (with an amber dot on the phone's menu button), and it
-  ends on its own at its time. Every orchestrator gets an event, and a line
+  ends on its own at its time. It works only through orchestrators that
+  had a real turn (yours or theirs, not an AgentOS event or a status poll)
+  in the last hour, set in Settings → Workspaces → Away mode; the rest
+  aren't told or woken. Each active orchestrator gets an event, and a line
   leading its digest, saying you're away and to follow work through rather
   than only react. Every 10 minutes a sweep, written as code with no model
-  scanning, acts on what it finds and logs each step in the orchestrator's
-  chat: a task quiet 30 minutes with no PR (or failing CI) is nudged, at most
-  twice; an idle task with uncommitted work and no PR is asked to commit and
-  open one or say why not; a PR green and settled whose review never started
-  or was lost has it run again (once seen on two sweeps, so the orchestrator
-  had its turn); and after each merge, the project's `deploy` check says
-  whether it went live and the server came back, with a failure sent to the
-  orchestrator as an event. Interactive sessions are yours: one with
-  uncommitted work is asked once to wrap up, and nothing more. Paused
+  scanning, runs a review again when a PR is green and settled but its
+  review never started or was lost (once seen on two sweeps, so the
+  orchestrator had its turn), checks after each merge whether the project's
+  `deploy` went live and the server came back, and sends the orchestrator
+  one digest of what's new: tasks quiet 30 minutes with no PR (or failing
+  CI), idle tasks with uncommitted work and no PR, and your own sessions
+  idle with uncommitted work. Only sessions with a real turn inside the
+  window are listed, never stopped, finished or archived ones, and nothing
+  goes out when nothing changed. The sweep messages no session itself: the
+  orchestrator decides what needs work, and asks one of your sessions at
+  most once to wrap up. Away's own messages don't count as activity. Paused
   workspaces aren't swept. Hard lines still become asks, and while you're
   away the asks raised, failed deploys and any `aos notify` an orchestrator
   sends reach your phone as one message per sweep. Turning it off (or its running out) builds "While you were
-  away" from the database: what merged and deployed with PR links, what's
-  still in flight and which gate or blocker holds it, what failed, was dropped
+  away" from the database, for the workspaces Away reached: what merged and
+  deployed with PR links, what the sweep flagged that's still in flight and
+  which gate or blocker holds it, what failed, was dropped
   or was escalated, and what waits on you (an explicit "none"). It opens on
   whichever device is open until you dismiss it, a short summary goes to
   your phone, and the report stays in Settings → Audits (`away/`).

package/app/api/away/settings/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { awayWindowMinutes, setAwayWindowMinutes } from "@/lib/away/activity";
+
+// GET /api/away/settings - how recent a session's last real turn must be
+// for Away mode to touch it (lib/away/activity).
+export function GET() {
+  return NextResponse.json({ windowMinutes: awayWindowMinutes() });
+}
+
+// PUT /api/away/settings - { windowMinutes }. From a trusted place, as
+// turning Away on is.
+export async function PUT(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  try {
+    const { windowMinutes } = (await request.json().catch(() => ({}))) as {
+      windowMinutes?: unknown;
+    };
+    setAwayWindowMinutes(windowMinutes);
+    return NextResponse.json({ windowMinutes: awayWindowMinutes() });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/components/Away/AwayWindowForm.tsx

@@ -0,0 +1,91 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  useAwaySettingsQuery,
+  useUpdateAwaySettings,
+  type AwaySettings,
+} from "@/data/away";
+import {
+  MAX_WINDOW_MINUTES,
+  MIN_WINDOW_MINUTES,
+  parseWindow,
+} from "@/lib/away/window-limits";
+
+// Settings → Workspaces: how recent a session's work must be for Away mode
+// to touch it. App-wide.
+export function AwayWindowForm() {
+  const { data, isPending, isError, error } = useAwaySettingsQuery();
+  if (isPending)
+    return <div className="bg-muted/40 h-24 animate-pulse rounded-lg" />;
+  if (isError)
+    return <p className="text-destructive text-sm">{error.message}</p>;
+  return <Form key={data.windowMinutes} saved={data} />;
+}
+
+function Form({ saved }: { saved: AwaySettings }) {
+  const update = useUpdateAwaySettings();
+  const [text, setText] = useState(String(saved.windowMinutes));
+  const minutes = parseWindow(text);
+  const error =
+    minutes === null
+      ? `A whole number from ${MIN_WINDOW_MINUTES} to ${MAX_WINDOW_MINUTES}`
+      : null;
+  return (
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        if (minutes === null) return;
+        update.mutate(
+          { windowMinutes: minutes },
+          {
+            onSuccess: () => toast.success("Away mode settings saved"),
+            onError: (err) => toast.error(err.message),
+          }
+        );
+      }}
+      className="bg-muted/40 space-y-3 rounded-lg px-3 py-3"
+    >
+      <h3 className="text-sm font-medium">Away mode</h3>
+      <p className="text-muted-foreground text-sm">
+        Away mode works through orchestrators that were busy in this window, and
+        only lists sessions with a real turn inside it. Older ones are left
+        alone: a message wakes an agent and re-reads its whole conversation.
+      </p>
+      <label className="flex items-center justify-between gap-3 text-sm">
+        <span className="text-muted-foreground">Recent means the last</span>
+        <span className="flex items-center gap-2">
+          <Input
+            type="number"
+            inputMode="numeric"
+            min={MIN_WINDOW_MINUTES}
+            max={MAX_WINDOW_MINUTES}
+            step={1}
+            value={text}
+            onChange={(e) => setText(e.target.value)}
+            aria-label="Away window, minutes"
+            aria-invalid={!!error}
+            className="h-11 w-24 text-base sm:h-9 md:text-sm"
+          />
+          <span className="text-muted-foreground">min</span>
+        </span>
+      </label>
+      {error && <p className="text-destructive text-xs">{error}</p>}
+      <div className="flex justify-end">
+        <Button
+          type="submit"
+          size="sm"
+          className="h-11 sm:h-8"
+          disabled={
+            !!error || minutes === saved.windowMinutes || update.isPending
+          }
+        >
+          Save
+        </Button>
+      </div>
+    </form>
+  );
+}

package/components/Workspaces/WorkspaceSettings.tsx

@@ -6,6 +6,7 @@ import { TaskLimitForm } from "./TaskLimitForm";
 import { RulesForm } from "./RulesForm";
 import { FreshStartForm } from "./FreshStartForm";
 import { WorkspaceModelsForm } from "./WorkspaceModelsForm";
+import { AwayWindowForm } from "@/components/Away/AwayWindowForm";
 
 // Settings > Workspaces: each workspace's own settings.
 export function WorkspaceSettings() {
@@ -52,6 +53,7 @@ export function WorkspaceSettings() {
         </section>
       ))}
       <FreshStartForm />
+      <AwayWindowForm />
     </div>
   );
 }

package/data/away/index.ts

@@ -71,3 +71,39 @@ export function awayEnds(d: AwayDuration, now = new Date()): Date | null {
   if (now.getHours() >= 5) morning.setDate(morning.getDate() + 1);
   return morning;
 }
+
+// How recent a session's last real turn must be for Away mode to touch it.
+export interface AwaySettings {
+  windowMinutes: number;
+}
+
+const settingsKey = [...awayKeys.all, "settings"] as const;
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `Request failed (${res.status})`);
+  return data;
+}
+
+export function useAwaySettingsQuery() {
+  return useQuery({
+    queryKey: settingsKey,
+    queryFn: async () => json<AwaySettings>(await fetch("/api/away/settings")),
+    staleTime: 60_000,
+  });
+}
+
+export function useUpdateAwaySettings() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (settings: AwaySettings) =>
+      json<AwaySettings>(
+        await fetch("/api/away/settings", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(settings),
+        })
+      ),
+    onSuccess: (data) => queryClient.setQueryData(settingsKey, data),
+  });
+}

package/lib/away/activity.ts

@@ -0,0 +1,147 @@
+/**
+ * Real activity, for Away mode: when a session last had a user or agent
+ * turn. Not `updated_at` (status polls bump it) and not tmux's activity
+ * clock where a better one exists, and never a turn Away mode itself
+ * started (an away line or digest an orchestrator was sent). The window
+ * past which a session counts as left alone is app-wide, in Settings →
+ * Workspaces.
+ */
+
+import fs from "fs";
+import { db, type Session } from "../db";
+import type { ChatOrigin } from "../chat/events";
+import { chatState } from "../chat/runner";
+import { runningWorkers } from "../chat/worker/client";
+import { statusDetector } from "../status-detector";
+import { expandHome } from "../tasks/session";
+import { isClaudeSessionId, transcriptPath } from "../tasks/transcript";
+
+import {
+  DEFAULT_WINDOW_MINUTES,
+  MAX_WINDOW_MINUTES,
+  MIN_WINDOW_MINUTES,
+} from "./window-limits";
+
+export const WINDOW_KEY = "away.window_minutes";
+
+export function awayWindowMinutes(): number {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(WINDOW_KEY) as { value: string } | undefined;
+  const n = row ? Number(row.value) : DEFAULT_WINDOW_MINUTES;
+  return Number.isInteger(n) &&
+    n >= MIN_WINDOW_MINUTES &&
+    n <= MAX_WINDOW_MINUTES
+    ? n
+    : DEFAULT_WINDOW_MINUTES;
+}
+
+export const awayWindowMs = () => awayWindowMinutes() * 60_000;
+
+export function setAwayWindowMinutes(value: unknown): number {
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < MIN_WINDOW_MINUTES ||
+    value > MAX_WINDOW_MINUTES
+  )
+    throw new Error(
+      `The window is a whole number of minutes from ${MIN_WINDOW_MINUTES} to ${MAX_WINDOW_MINUTES}`
+    );
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(WINDOW_KEY, String(value));
+  return value;
+}
+
+// Kinds a turn writes; notes, errors, compactions and MCP listings aren't
+// anyone working.
+const TURN_KINDS = new Set([
+  "user",
+  "assistant",
+  "reasoning",
+  "tool",
+  "todos",
+  "plan",
+  "artifact",
+  "turn_end",
+]);
+const SCAN = 200;
+
+interface Item {
+  kind?: string;
+  createdAt?: number;
+  origin?: ChatOrigin;
+}
+
+// Newest first: a turn's items come before the message that started it.
+// A turn Away mode started doesn't count; one an event, a peer or a
+// schedule started counts from its first reply, not from the message.
+export function lastChatTurn(items: Item[]): number {
+  let reply = 0;
+  for (const item of items) {
+    if (!item.kind || !TURN_KINDS.has(item.kind)) continue;
+    const at = item.createdAt ?? 0;
+    if (item.kind !== "user") {
+      reply = Math.max(reply, at);
+      continue;
+    }
+    const origin = item.origin;
+    if (origin?.away) {
+      reply = 0;
+      continue;
+    }
+    // Typed by the reader, or the reader's own decision.
+    if (!origin || origin.kind === "decision") return Math.max(reply, at);
+    if (reply) return reply;
+  }
+  return reply;
+}
+
+function chatTurn(sessionId: string): number {
+  const rows = db
+    .prepare(
+      `SELECT data FROM chat_items WHERE session_id = ? ORDER BY seq DESC LIMIT ?`
+    )
+    .all(sessionId, SCAN) as { data: string }[];
+  return lastChatTurn(
+    rows.map((r) => {
+      try {
+        return JSON.parse(r.data) as Item;
+      } catch {
+        return {};
+      }
+    })
+  );
+}
+
+// A terminal's Claude conversation file is written on every turn and on
+// nothing else; other agents fall back to tmux's output clock, which a
+// status poll (capture-pane) doesn't move.
+function terminalTurn(s: Session): number {
+  if (s.claude_session_id && isClaudeSessionId(s.claude_session_id)) {
+    try {
+      const cwd = expandHome(s.worktree_path || s.working_directory);
+      return fs.statSync(transcriptPath(cwd, s.claude_session_id)).mtimeMs;
+    } catch {
+      // No file here: fall through.
+    }
+  }
+  return (
+    statusDetector.getTimestamp(s.tmux_name, s.host_id || undefined) * 1000
+  );
+}
+
+export function lastTurnAt(s: Session): number {
+  return s.view === "chat" ? chatTurn(s.id) : terminalTurn(s);
+}
+
+// Whether a chat's agent is up: a worker that went idle long enough exits,
+// and a message would start it again and re-read the whole conversation.
+// A terminal's is its tmux session (facts say "dead" when it's gone).
+export function agentLive(s: Session): boolean {
+  if (s.view !== "chat")
+    return statusDetector.sessionExists(s.tmux_name, s.host_id || undefined);
+  return chatState(s.id) !== null || runningWorkers().includes(s.id);
+}

package/lib/away/brief.ts

@@ -7,17 +7,25 @@ import {
   activeAway,
   clockTime,
   fromSql,
+  reachedWorkspaces,
   untilText,
   type AwayRow,
 } from "./state";
 import { SWEEP_EVERY_MS } from "./sweep";
+import { awayWindowMinutes } from "./activity";
 
 export function awayOnLine(row: AwayRow, now = Date.now()): string {
-  return `Saad is away (Away mode, since ${clockTime(fromSql(row.started_at), now)}, ${untilText(row, now)}). Follow work through rather than only reacting to events: keep each task moving to merged and deployed, sign off what passes its gates, and pick up what stalled. Every ${SWEEP_EVERY_MS / 60000} minutes AgentOS sweeps: it nudges stalled tasks, asks idle ones with uncommitted work to commit and open a PR, runs lost reviews again and checks the deploy after each merge; what needs you comes as events, and each step is in your log. Interactive sessions (not tasks) are Saad's: in Away mode only ask them to wrap up, never drive them further. Hard lines still go to ask_saad; while he's away his asks reach his phone in one batch per sweep, so raise them as usual. \`aos notify\` is held for that batch too, so don't send one per item.`;
+  return `Saad is away (Away mode, since ${clockTime(fromSql(row.started_at), now)}, ${untilText(row, now)}). Follow work through rather than only reacting to events: keep each task moving to merged and deployed, sign off what passes its gates, and pick up what stalled. Every ${SWEEP_EVERY_MS / 60000} minutes AgentOS sweeps this workspace without messaging any session: it runs lost reviews again, checks the deploy after each merge, and sends you one digest of what's new (stalled tasks, idle ones with uncommitted work and no PR, Saad's own sessions idle with uncommitted work). You decide what needs work and act with your tools. Only sessions with real activity in the last ${awayWindowMinutes()} minutes are listed: leave the rest alone, since a message wakes an agent and re-reads its whole context. Interactive sessions (not tasks) are Saad's: ask a listed one at most once to wrap up, never drive them further. Hard lines still go to ask_saad; while he's away his asks reach his phone in one batch per sweep, so raise them as usual. \`aos notify\` is held for that batch too, so don't send one per item.`;
 }
 
-// For the digest: the same line while Away is on, else nothing.
-export function awayDigestLine(now = Date.now()): string | null {
+// For the digest: the same line while Away is on and has reached this
+// workspace, else nothing.
+export function awayDigestLine(
+  workspaceId: string,
+  now = Date.now()
+): string | null {
   const row = activeAway();
-  return row ? awayOnLine(row, now) : null;
+  return row && reachedWorkspaces(row.id).has(workspaceId)
+    ? awayOnLine(row, now)
+    : null;
 }

package/lib/away/report.ts

@@ -87,19 +87,22 @@ export function inFlightWhy(t: {
   checks: CheckRow[];
   failures: FailureRow[];
   askKinds: string[];
-  nudges: number;
+  // Times the sweep listed it for its orchestrator this period.
+  flagged: number;
 }): string {
   const escalated = t.failures.filter((f) => f.escalated_at);
   if (escalated.length)
     return `with you: the ${escalated.map((f) => f.gate).join(" and ")} gate failed twice`;
   if (t.askKinds.length) return `waiting on your answer (${t.askKinds[0]})`;
-  const nudged = t.nudges ? `; nudged ${t.nudges}x while you were away` : "";
-  if (!t.prNumber) return `no PR yet${nudged}`;
+  const flagged = t.flagged
+    ? `; flagged to the orchestrator ${t.flagged}x while you were away`
+    : "";
+  if (!t.prNumber) return `no PR yet${flagged}`;
   const of = (kind: string) => t.checks.find((c) => c.kind === kind);
   const review = of("review");
   const ci = of("ci");
   if (ci && ci.status !== "pass" && ci.status !== "running")
-    return `CI failing at ${sha7(ci.sha)}${nudged}`;
+    return `CI failing at ${sha7(ci.sha)}${flagged}`;
   if (review?.status === "block")
     return `review found blocking issues at ${sha7(review.sha)}`;
   const failed = t.failures.filter((f) => f.count > 0);
@@ -113,6 +116,9 @@ export function inFlightWhy(t: {
   return "PR open and reviewed, waiting on sign-off";
 }
 
+// What the sweep did to a task (./run), not just saw.
+const TOUCHED = "'stalled', 'commit', 'review'";
+
 interface TaskRow {
   id: string;
   name: string;
@@ -165,6 +171,8 @@ function merged(
   });
 }
 
+// Running tasks the sweep touched: listed for the orchestrator, or their
+// review run again. Ones it left alone aren't counted.
 function inFlight(workspaceId: string, awayId: number): InFlightItem[] {
   const tasks = db
     .prepare(
@@ -173,16 +181,18 @@ function inFlight(workspaceId: string, awayId: number): InFlightItem[] {
        FROM sessions s JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
          AND s.task_status = 'running'
+         AND EXISTS (SELECT 1 FROM away_actions a WHERE a.away_id = ?
+           AND a.subject = s.id AND a.kind IN (${TOUCHED}))
        ORDER BY s.created_at, s.id`
     )
-    .all(workspaceId) as TaskRow[];
+    .all(workspaceId, awayId) as TaskRow[];
   if (!tasks.length) return [];
   const checks = checksBySession(workspaceId);
   const failures = failuresBySession(workspaceId);
   const asks = openAsks(workspaceId);
-  const nudges = db.prepare(
+  const flagged = db.prepare(
     `SELECT COUNT(*) AS n FROM away_actions
-     WHERE away_id = ? AND subject = ? AND kind = 'nudge'`
+     WHERE away_id = ? AND subject = ? AND kind IN ('stalled', 'commit')`
   );
   return tasks.map((t) => ({
     task: t.name,
@@ -197,7 +207,7 @@ function inFlight(workspaceId: string, awayId: number): InFlightItem[] {
       askKinds: asks
         .filter((a) => a.subject === `task:${t.id}`)
         .map((a) => a.kind),
-      nudges: (nudges.get(awayId, t.id) as { n: number }).n,
+      flagged: (flagged.get(awayId, t.id) as { n: number }).n,
     }),
   }));
 }
@@ -261,12 +271,16 @@ function waiting(workspaceId: string): WaitingItem[] {
   }));
 }
 
+// Only the workspaces Away mode reached (`reached`, whose orchestrator was
+// active and told); the rest were left alone.
 export function buildAwayReport(
   away: AwayRow,
-  deployConfigured: (projectId: string) => boolean
+  deployConfigured: (projectId: string) => boolean,
+  reached: ReadonlySet<string>
 ): AwayReport {
   const end = away.ended_at ?? away.started_at;
   const workspaces = listWorkspaces()
+    .filter((w) => reached.has(w.id))
     .map((w) => ({
       id: w.id,
       name: w.name,

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.

package/lib/models/roles.ts

@@ -53,7 +53,7 @@ export const DEFAULT_ROLE_MODELS: Record<ModelRole, string> = {
   plan: OPUS,
   review: OPUS,
   implement: SONNET,
-  orchestrator: SONNET,
+  orchestrator: OPUS,
   scope: SONNET,
   interactive: OPUS,
   helper: HAIKU,

package/lib/orchestrator/deliver.ts

@@ -2,6 +2,7 @@ import type { ChatOrigin, ChatState } from "../chat/events";
 import type { CompactFirst } from "../chat/stale";
 import {
   isAnswer,
+  isAwayEvent,
   deliveriesSince,
   lastDeliveredAt,
   logDeliveries,
@@ -91,6 +92,7 @@ export async function deliverEvents(opts: {
     kind: "event",
     label: "AgentOS",
     ...(decided.length ? { decided } : {}),
+    ...(pending.every((e) => isAwayEvent(e)) ? { away: true as const } : {}),
   };
   markDelivered(ids, now);
   const logged = logDeliveries(

package/lib/orchestrator/digest.ts

@@ -324,7 +324,7 @@ export function buildDigest(
 ): string {
   const checks = checksBySession(workspaceId);
   const failures = failuresBySession(workspaceId);
-  const away = awayDigestLine();
+  const away = awayDigestLine(workspaceId);
   const head = `## Where things stand (read from AgentOS's database as you started)${away ? `\n\n${away}` : ""}`;
   const body = renderDigest(
     [

package/lib/orchestrator/events.ts

@@ -40,6 +40,9 @@ const ONCE = "once:";
 export const answerKey = (askId: number) => `ask:${askId}`;
 export const isAnswer = (e: Pick<EventRow, "key">) =>
   e.key.startsWith(`${ONCE}ask:`);
+// Away mode's own one-off lines (lib/away/run) all start "away".
+export const isAwayEvent = (e: Pick<EventRow, "key">) =>
+  e.key.startsWith(`${ONCE}away`);
 
 const iso = (ms: number) => new Date(ms).toISOString();
 

package/package.json

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