@saadnvd1/agent-os 0.3.516 → 0.3.518

package/lib/away/run.ts

@@ -19,6 +19,7 @@ import { review } from "../orchestrator/review";
 import { repoOf } from "../orchestrator/repo";
 import { clip } from "../orchestrator/digest";
 import { notifyPhone } from "../notify";
+import { takeFoldedPushes } from "../notify/push";
 import { getProject } from "../projects";
 import { loadProjectConfig } from "../project-config";
 import { run } from "../tasks/gh";
@@ -194,7 +195,11 @@ export function turnAwayOff(
   // no report), then the summary. A second later, so the window takes
   // everything up to now.
   notifyBatch(ended, now + 1000);
-  notifyPhone(PHONE_SOURCE, phoneSummary(report));
+  notifyPhone(PHONE_SOURCE, phoneSummary(report), {
+    category: "digest",
+    key: `digest:end:${ended.id}`,
+    collapse: "digest",
+  });
   return { ...ended, report: JSON.stringify(report) };
 }
 
@@ -516,7 +521,9 @@ export function notifyBatch(away: AwayRow, now = Date.now()): string | null {
   }[];
   const deploys = held.filter((h) => h.kind === "deploy_failed");
   const notes = held.filter((h) => h.kind === "notify");
-  if (!asks.length && !held.length) return null;
+  // What push held for this digest (ready for review, CI, agent messages).
+  const pushed = takeFoldedPushes(now);
+  if (!asks.length && !held.length && !pushed) return null;
   const lines = [
     ...deploys.map(
       (d) => `- ${d.workspace}: deploy failed: ${clip(d.detail ?? "", 120)}`
@@ -534,6 +541,7 @@ export function notifyBatch(away: AwayRow, now = Date.now()): string | null {
       "note from an orchestrator",
       "notes from orchestrators"
     ),
+    ...count(pushed, "other update", "other updates"),
   ];
   const head = `While you're away: ${parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}` : parts[0]}`;
   const shown = lines.slice(0, PHONE_LINES);
@@ -541,7 +549,11 @@ export function notifyBatch(away: AwayRow, now = Date.now()): string | null {
   const text = [head, ...shown, ...(more ? [`- and ${more} more`] : [])].join(
     "\n"
   );
-  notifyPhone(PHONE_SOURCE, text);
+  notifyPhone(PHONE_SOURCE, text, {
+    category: "digest",
+    key: `digest:${away.id}:${now}`,
+    collapse: "digest",
+  });
   return text;
 }
 

package/lib/bus/index.ts

@@ -14,6 +14,8 @@ import { previousNames } from "../session-names";
 import { deliverToPane, type Delivery } from "./delivery";
 import { resolveRef, wasNames, type Candidate } from "./resolve";
 import { tmuxPane } from "./tmux-pane";
+import { hostLink } from "../hosts/remote-api";
+import { relayToHeldTask } from "../tasks/held-remote";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
 
 export * from "./format";
@@ -142,11 +144,21 @@ function pairTimestamps(a: string | null, b: string): number[] {
 
 // Hands the message to the recipient: a chat session's worker, or typed
 // into a terminal's pane and checked that it went in.
-async function deliver(
+export async function deliver(
   to: Session,
   line: string,
-  from: { name: string; peer?: PeerMessage; origin?: ChatOrigin }
+  from: {
+    name: string;
+    peer?: PeerMessage;
+    origin?: ChatOrigin;
+    // The stored message's id, which a relayed one is keyed by.
+    messageId?: number;
+  }
 ): Promise<Delivery> {
+  // A task this machine's orchestrator moved to a linked machine: that
+  // machine's AgentOS delivers it, labelled as the orchestrator's (held.ts).
+  if (to.task_prompt && to.started_by && hostLink(to.host_id))
+    return relayToHeldTask(to, line, from.name, from.messageId);
   // A linked machine's own session: an agent's message would reach it as
   // the user's (see runner.ts), so none is relayed yet.
   if (to.peer_mirror && !to.task_prompt)
@@ -228,6 +240,7 @@ export async function sendMessage(opts: {
     opts.line ?? wakeLine({ fromName, fromId: from?.id ?? null, body }),
     {
       name: fromName,
+      messageId: id,
       peer: from ? { sessionId: from.id, body } : undefined,
       origin: from
         ? { kind: "peer", label: from.name, sessionId: from.id }

package/lib/chat/registry.ts

@@ -1,3 +1,4 @@
+import { noteWaiting } from "../notify/push/waiting";
 import { db, type Session } from "../db";
 import type { WorkerClient } from "./worker/client";
 import { notifyStatusChanged } from "../status/hub";
@@ -90,6 +91,7 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
   // Items come from the worker, which writes them a moment after saying so.
   if (m.type === "state" || m.type === "compacting" || m.type === "item")
     markStatusDirty(sessionId, EMIT_SETTLE_MS);
+  if (m.type === "state") noteWaiting(sessionId, m.state === "waiting");
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.

package/lib/chat/runner.ts

@@ -5,6 +5,7 @@
  * events to whoever is watching. Restarting the server leaves turns running.
  */
 
+import { pushPlanReady } from "../notify/push/events";
 import { handoffAfterPlan } from "../models/plan-step";
 import { randomUUID } from "crypto";
 import os from "os";
@@ -152,6 +153,8 @@ function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
   if (e.type === "item" && e.item.kind === "task")
     retireIfStale(sessionId, live);
   if (e.type === "item") {
+    if (e.item.kind === "plan" && !e.item.carried)
+      pushPlanReady(sessionId, e.item.id);
     if ("streaming" in e.item && e.item.streaming)
       live.streaming.set(e.item.id, e.item);
     else live.streaming.delete(e.item.id);

package/lib/connect/control-api.ts

@@ -226,3 +226,41 @@ export async function heartbeat(
   );
   return (await res.json()) as { enabled: boolean };
 }
+
+export interface PushRequestBody {
+  v: 1;
+  devices: { token: string; env: "production" | "sandbox" }[];
+  push_type: "alert" | "background";
+  priority: 10 | 5;
+  level: "passive" | "active" | "time-sensitive";
+  collapse_id?: string;
+  thread_id?: string;
+  payload: Record<string, unknown>;
+}
+
+export interface PushResult {
+  status: "sent" | "gone" | "retry" | "rejected";
+  apns_status?: number;
+  reason?: string;
+  prune?: boolean;
+  retry_after?: number;
+}
+
+/** One APNs send per device, answered in device order. Signed. */
+export async function pushRelay(
+  config: ConnectConfig,
+  privateKey: string,
+  body: PushRequestBody
+): Promise<PushResult[]> {
+  const res = await signed(config, privateKey)(
+    "POST",
+    `/api/v1/machines/${config.machineId}/push`,
+    body
+  );
+  const r = (await res.json().catch(() => null)) as {
+    results?: PushResult[];
+  } | null;
+  if (!Array.isArray(r?.results))
+    throw new Error("the Connect service sent no push results");
+  return r.results;
+}

package/lib/db/migrations.ts

@@ -1658,6 +1658,62 @@ const migrations: Migration[] = [
       );
     },
   },
+  {
+    id: 72,
+    name: "push_outbox",
+    up: (db) => {
+      // One row per (event, device). device_id is '' for a row folded into
+      // the Away digest. state: pending, sending, sent, failed, gone,
+      // capped, superseded, folded, digested.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS push_outbox (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          event_key TEXT NOT NULL,
+          device_id TEXT NOT NULL,
+          category TEXT NOT NULL,
+          level TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          collapse_id TEXT,
+          state TEXT NOT NULL,
+          attempts INTEGER NOT NULL DEFAULT 0,
+          next_attempt_at INTEGER NOT NULL,
+          created_at INTEGER NOT NULL,
+          sent_at INTEGER,
+          error TEXT,
+          fallback_source TEXT,
+          fallback_text TEXT,
+          UNIQUE(event_key, device_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_push_outbox_due ON push_outbox(state, next_attempt_at);
+        CREATE INDEX IF NOT EXISTS idx_push_outbox_device ON push_outbox(device_id, sent_at);
+      `);
+    },
+  },
+  {
+    id: 73,
+    name: "orchestrated_task_moves",
+    up: (db) => {
+      // task_since: when the task first started, kept across moves (null:
+      // created_at). held_by_device / held_from: the device and machine of
+      // the orchestrator that moved this task here; only that device may
+      // merge, arm, message or move it. plan_note: the "plan written" line
+      // of a held task, for its orchestrator to read.
+      const add = (col: string) => {
+        const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+          name: string;
+        }[];
+        if (!columns.some((c) => c.name === col))
+          db.exec(`ALTER TABLE sessions ADD COLUMN ${col} TEXT`);
+      };
+      for (const col of [
+        "task_since",
+        "held_by_device",
+        "held_from",
+        "plan_note",
+      ])
+        add(col);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -119,6 +119,13 @@ export interface Session {
   rebase_asked_head?: string | null;
   // When its PR's reviews and comments started being watched (pr-wake.ts).
   pr_wake_since?: string | null;
+  // When the task first started, kept across moves (null: created_at).
+  task_since?: string | null;
+  // The device and machine of the orchestrator that moved this task here.
+  held_by_device?: string | null;
+  held_from?: string | null;
+  // A held task's "plan written" line, for its orchestrator to read.
+  plan_note?: string | null;
   // Orchestration fields
   conductor_session_id: string | null;
   worker_task: string | null;

package/lib/done/bulk.ts

@@ -54,6 +54,8 @@ function scopeSessions(scope: DoneScope): Session[] {
          AND role IS NULL AND archived_at IS NULL
          -- A linked machine's own sessions are cleaned up there.
          AND peer_mirror = 0
+         -- A task another machine's orchestrator moved here is its to finish.
+         AND held_by_device IS NULL
          AND (task_status IS NULL OR task_status = 'running')
        ORDER BY created_at`
     )
@@ -75,6 +77,12 @@ export async function idleSessions(
 
 // The caller's workspace when its project has one, else its project.
 export function scopeOf(session: Session): DoneScope {
+  // An orchestrator acts through its tools, which Pause holds and which are
+  // logged; aos would reach the same sessions past both.
+  if (session.role === "orchestrator")
+    throw new Error(
+      `${session.name} is an orchestrator: it moves, finishes and stops sessions with its move, done and stop tools, not aos`
+    );
   const project = session.project_id ? getProject(session.project_id) : null;
   if (!project || project.is_uncategorized)
     throw new Error(`${session.name} isn't in a project`);

package/lib/done/index.ts

@@ -25,7 +25,10 @@ import { sessionMergePolicy } from "../tasks/finish";
 import { releasePorts } from "../ports";
 import { dropSessionDatabase } from "../project-config/database";
 import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
+import { hostLink } from "../hosts/remote-api";
+import { doneHeldTask } from "../tasks/held-remote";
 import { captureMergedTask } from "../session-logs";
+import { pushMerged } from "../notify/push/events";
 
 export interface DoneOptions {
   // Who asked: the orchestrator's gate failures count toward Saad, as its
@@ -103,7 +106,10 @@ function mark(s: Session, status: "merged" | "done", pr: TaskPR | null) {
       : `UPDATE sessions SET task_status = 'done' WHERE id = ?`
   ).run(s.id);
   syncTaskCardInBackground(s, status, pr);
-  if (status === "merged") void captureMergedTask(s.id, { head: pr?.head });
+  if (status === "merged") {
+    pushMerged(s.id);
+    void captureMergedTask(s.id, { head: pr?.head });
+  }
 }
 
 export async function doneSession(
@@ -157,6 +163,19 @@ export async function doneSession(
     await stopAgent(s);
     // The sign-off's cleanup has already settled it; this reads the result.
     worktree = await settleWorktree(s, { prHead: m.sha });
+  } else if (s.started_by && s.task_prompt && hostLink(s.host_id)) {
+    // Moved to a linked machine by its orchestrator: that machine stops the
+    // agent and removes the worktree, which is where they are.
+    await doneHeldTask(s);
+    if (plan.mark) mark(s, plan.mark, plan.pr);
+    else
+      db.prepare(
+        `UPDATE sessions SET task_status = 'done' WHERE id = ? AND task_status = 'running'`
+      ).run(s.id);
+    worktree = {
+      action: "removed",
+      why: `on ${hostLink(s.host_id)?.hostName ?? "its machine"}`,
+    };
   } else {
     if (plan.mark) mark(s, plan.mark, plan.pr);
     if (

package/lib/load/alert.ts

@@ -30,7 +30,11 @@ const BACK_OFF =
   "Ask your running tasks to use targeted tests and hold off on full suites, type checks and builds until it clears. Nothing has been stopped.";
 
 export function raiseAlert(text: string): void {
-  notifyPhone("load", text);
+  notifyPhone("load", text, {
+    category: "system",
+    key: `system:load:${Date.now()}`,
+    collapse: "system:load",
+  });
   for (const orch of listOrchestrators()) {
     if (orch.archived_at) continue;
     sendMessage({

package/lib/models/plan-step.ts

@@ -73,9 +73,12 @@ export function planSummary(text: string, max = 5): string[] {
 
 // Tells the orchestrator that started a task its plan is written, once.
 function announcePlan(s: Session, ref: string): void {
-  if (!s.started_by) return;
+  if (!s.started_by && !s.held_by_device) return;
   const workspaceId = sessionWorkspace(s);
-  if (!workspaceId || !s.worktree_path) return;
+  // A task held for another machine's orchestrator can't reach it: the line
+  // waits on the task for that orchestrator to read (orchestrator/facts).
+  if (!s.held_by_device && !workspaceId) return;
+  if (!s.worktree_path) return;
   const file = path.join(s.worktree_path, PLAN_FILE);
   let head = `Task "${s.name}": no plan file was written; implementing on ${ref} anyway.`;
   try {
@@ -85,7 +88,14 @@ function announcePlan(s: Session, ref: string): void {
   } catch {
     // No plan file: the line says so.
   }
-  queueEvent(workspaceId, `plan-done:${s.id}`, s.id, head);
+  if (s.held_by_device) {
+    db.prepare(`UPDATE sessions SET plan_note = ? WHERE id = ?`).run(
+      head,
+      s.id
+    );
+    return;
+  }
+  queueEvent(workspaceId!, `plan-done:${s.id}`, s.id, head);
 }
 
 export const implementMessageId = (sessionId: string) =>

package/lib/notify/index.ts

@@ -9,6 +9,9 @@ import { db, type Session } from "../db";
 import { Limiter, type Outcome } from "./limiter";
 import { holdForBatch, msToNextSweep } from "../away/state";
 import { selectNotifier, type TelegramConfig } from "./notifiers";
+import { pushAvailable, pushEvent } from "./push";
+import { setFallbackSink } from "./push/sender";
+import type { PushCategory } from "./push-types";
 
 export type { Outcome } from "./limiter";
 
@@ -99,6 +102,23 @@ export function resumePhoneOutbox(): void {
   }
 }
 
+// Held text that push couldn't deliver goes to Telegram once.
+setFallbackSink(async (source, text) => {
+  const outcome = await limiter().push(source, text);
+  if (outcome.state === "failed") throw new Error(outcome.why);
+});
+
+// Which phone-app category a message belongs to. A message with one goes to
+// a registered device instead of Telegram, and to Telegram if push is off.
+export interface PushRoute {
+  category: PushCategory;
+  id?: string | null;
+  key?: string | null;
+  collapse?: string | null;
+  /** The session it is about, so a mirror of another machine's never pushes. */
+  sessionId?: string | null;
+}
+
 export class NotConfigured extends Error {
   constructor() {
     super(
@@ -111,10 +131,21 @@ export class NotConfigured extends Error {
 // NotConfigured when nothing would send it.
 export async function sendPhone(
   source: string,
-  text: string
+  text: string,
+  push?: PushRoute
 ): Promise<Outcome> {
   const body = text.trim();
   if (!body) throw new Error("Nothing to send");
+  if (push && pushAvailable()) {
+    const { sessionId, ...event } = push;
+    const out = await pushEvent(event, {
+      sessionId,
+      fallback: { source, text: body },
+    });
+    if (out === "queued") return { state: "pushed" };
+    if (out === "folded") return { state: "held", inMs: msToNextSweep() };
+    if (out === "dropped" || out === "muted") return { state: "skipped" };
+  }
   if (!selectNotifier(process.env, telegramConfig())) throw new NotConfigured();
   const outcome = await limiter().push(source, body);
   if (outcome.state === "failed")
@@ -142,15 +173,23 @@ export async function notifyFrom(
     holdForBatch(session.workspace_id, session.id, body)
   )
     return { state: "held", inMs: msToNextSweep() };
-  return sendPhone(
-    session ? `session:${session.id}` : "cli",
-    session ? `${session.name}: ${body}` : body
-  );
+  const source = session ? `session:${session.id}` : "cli";
+  return sendPhone(source, session ? `${session.name}: ${body}` : body, {
+    category: "agents",
+    id: session?.id,
+    key: `agents:${session?.id ?? "cli"}:${Date.now()}`,
+    collapse: `agents:${session?.id ?? "cli"}`,
+    sessionId: session?.id,
+  });
 }
 
 // For the server's own alerts: never throws, never waits on the send.
-export function notifyPhone(source: string, text: string): void {
-  sendPhone(source, text).catch((error) => {
+export function notifyPhone(
+  source: string,
+  text: string,
+  push?: PushRoute
+): void {
+  sendPhone(source, text, push).catch((error) => {
     if (!(error instanceof NotConfigured))
       console.error(
         `[notify] ${source}:`,

package/lib/notify/limiter.ts

@@ -16,7 +16,12 @@ export type Outcome =
   | { state: "held"; inMs: number }
   | { state: "duplicate" }
   | { state: "dropped" }
-  | { state: "failed"; why: string };
+  | { state: "failed"; why: string }
+  // Went to the phone app; Telegram only steps in if that fails.
+  | { state: "pushed" }
+  // Push had nothing to do: the device turned the category off, or Saad is
+  // at the Mac.
+  | { state: "skipped" };
 
 export function collapse(texts: string[]): string {
   if (texts.length === 1) return texts[0];

package/lib/notify/push/encode.ts

@@ -0,0 +1,42 @@
+/**
+ * The one place an event becomes the bytes the relay is given. v1 is the
+ * generic, content-free envelope. Encrypted rich text (v2) replaces the body
+ * of this function and nothing else: callers hand over an event, never a
+ * payload.
+ */
+
+import crypto from "crypto";
+import { buildPushPayload, isGenericPayload } from "../copy";
+import type { PushEnvelope, PushEvent, PushLevel } from "../push-types";
+
+export interface EncodedPush {
+  payload: PushEnvelope;
+  level: PushLevel;
+  priority: 10 | 5;
+  /** Opaque: a hash, so the relay and Apple learn nothing from it. */
+  collapseId: string;
+  threadId: string;
+}
+
+/** Same event key, same id, on every machine that sends it. */
+export const collapseId = (key: string) =>
+  crypto.createHash("sha256").update(key).digest("hex").slice(0, 32);
+
+export function encodePush(
+  event: PushEvent,
+  _device?: { id: string }
+): EncodedPush {
+  const payload = buildPushPayload({ ...event, key: null });
+  // Nothing but what the registry could have built may leave the machine.
+  if (!isGenericPayload(payload))
+    throw new Error(
+      "refusing to send a push payload the registry didn't build"
+    );
+  return {
+    payload,
+    level: payload.p,
+    priority: payload.p === "passive" ? 5 : 10,
+    collapseId: collapseId(event.collapse ?? event.key ?? payload.k),
+    threadId: event.category,
+  };
+}

package/lib/notify/push/events.ts

@@ -0,0 +1,72 @@
+/**
+ * One helper per event that can reach the phone. Each is fire-and-forget:
+ * a failure here must never touch the code that raised the event.
+ */
+
+import { db } from "../../db";
+import { pushEvent } from "./index";
+import type { PushEvent } from "../push-types";
+
+function fire(event: PushEvent, sessionId?: string | null): void {
+  pushEvent(event, { sessionId }).catch((error) =>
+    console.error(
+      `[push] ${event.category}:`,
+      error instanceof Error ? error.message : error
+    )
+  );
+}
+
+export const pushAskRaised = (askId: number, workspaceId: string) =>
+  fire({ category: "asks", id: workspaceId, key: `ask:${askId}` });
+
+export const pushNeedsYou = (sessionId: string, armedAt: number) =>
+  fire(
+    {
+      category: "needs-you",
+      id: sessionId,
+      key: `needs-you:${sessionId}:${armedAt}`,
+      collapse: `needs-you:${sessionId}`,
+    },
+    sessionId
+  );
+
+const forTask = (
+  category: "review" | "ci" | "merged",
+  prefix: string,
+  taskId: string,
+  sha?: string | null
+) =>
+  fire(
+    {
+      category,
+      id: taskId,
+      key: `${prefix}:${taskId}${sha ? `:${sha}` : ""}`,
+      collapse: `task:${taskId}`,
+    },
+    taskId
+  );
+
+export const pushReviewReady = (taskId: string, sha: string) =>
+  forTask("review", "review", taskId, sha);
+export const pushCiFailed = (taskId: string, sha: string) =>
+  forTask("ci", "ci", taskId, sha);
+export const pushReviewBlocked = (taskId: string, sha: string) =>
+  forTask("ci", "review-block", taskId, sha);
+export const pushMerged = (taskId: string) =>
+  forTask("merged", "merged", taskId);
+
+export const pushPlanReady = (sessionId: string, itemId: string) => {
+  // Only a task has a screen to open; a plain chat's plan goes to the list.
+  const task = db
+    .prepare(`SELECT task_status FROM sessions WHERE id = ?`)
+    .get(sessionId) as { task_status: string | null } | undefined;
+  fire(
+    {
+      category: "review",
+      id: task?.task_status ? sessionId : null,
+      key: `plan:${sessionId}:${itemId}`,
+      collapse: `plan:${sessionId}`,
+    },
+    sessionId
+  );
+};