@saadnvd1/agent-os 0.3.474 → 0.3.477

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,