@saadnvd1/agent-os 0.3.516 → 0.3.518

package/lib/notify/push/sender.ts

@@ -0,0 +1,271 @@
+/**
+ * Drains the push outbox into the Connect relay. Never throws at a caller and
+ * never blocks one: `kick()` starts a drain and returns. Retries back off;
+ * a relay that says push isn't set up is left alone for ten minutes instead
+ * of being asked per message, and what was waiting falls back to Telegram.
+ */
+
+import type { PushRequestBody } from "@/lib/connect/control-api";
+import {
+  getDevicePush,
+  pruneDevicePush,
+  setDevicePushError,
+} from "@/lib/security/devices";
+import * as outbox from "./outbox";
+import { relaySend, type RelayAnswer } from "./relay";
+import { isTestKey, type OutboxRow } from "./outbox";
+
+export const MAX_ATTEMPTS = 3;
+const BACKOFF_MS = [30_000, 120_000];
+const MAX_BACKOFF_MS = 600_000;
+export const UNAVAILABLE_MS = 600_000;
+const BATCH = 10;
+/** Dead tokens are hex; anything else would make the relay refuse the batch. */
+const APNS_TOKEN = /^[0-9a-fA-F]{64,200}$/;
+
+export interface SenderDeps {
+  now: () => number;
+  relay: (body: PushRequestBody) => Promise<RelayAnswer>;
+  /** Sends a held message by the other channel. */
+  fallback: (source: string, text: string) => Promise<void>;
+  log: (line: string) => void;
+}
+
+type Sink = SenderDeps["fallback"];
+// On globalThis like the sender: the app's bundles each have their own copy
+// of this module, and the one that sets the sink may not be the one that built
+// the sender.
+const sinks = globalThis as unknown as { __agentosPushFallback?: Sink };
+
+/** Where held text goes when push can't deliver it (Telegram). */
+export function setFallbackSink(fn: Sink): void {
+  sinks.__agentosPushFallback = fn;
+}
+
+const defaults = (): SenderDeps => ({
+  now: () => Date.now(),
+  relay: relaySend,
+  fallback: async (source, text) => sinks.__agentosPushFallback?.(source, text),
+  log: (line) => console.error(`[push] ${line}`),
+});
+
+export class PushSender {
+  private deps: SenderDeps;
+  private running = false;
+  private again = false;
+  private current: Promise<void> = Promise.resolve();
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private down: { until: number; reason: string } | null = null;
+
+  constructor(deps: Partial<SenderDeps> = {}) {
+    this.deps = { ...defaults(), ...deps };
+  }
+
+  /** Why pushes aren't being tried right now, or null. */
+  unavailable(): string | null {
+    if (this.down && this.deps.now() >= this.down.until) this.down = null;
+    return this.down?.reason ?? null;
+  }
+
+  clearUnavailable(): void {
+    this.down = null;
+  }
+
+  /** Stops the retry timer (a test discarding its sender). */
+  dispose(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+
+  /** Starts a drain if none is running; resolves when it has caught up. */
+  kick(): Promise<void> {
+    if (this.running) {
+      this.again = true;
+      return this.current;
+    }
+    this.running = true;
+    this.current = this.drain().finally(() => {
+      this.running = false;
+      this.arm();
+    });
+    return this.current;
+  }
+
+  /** Re-arms after a restart. */
+  resume(): void {
+    outbox.resume(this.deps.now());
+    void this.kick();
+  }
+
+  private async drain(): Promise<void> {
+    try {
+      do {
+        this.again = false;
+        for (const key of outbox.expire(this.deps.now()))
+          await this.settle(key);
+        for (;;) {
+          const rows = outbox.claimDue(this.deps.now());
+          if (!rows.length) break;
+          const byEvent = new Map<string, OutboxRow[]>();
+          for (const r of rows)
+            byEvent.set(r.event_key, [...(byEvent.get(r.event_key) ?? []), r]);
+          for (const group of byEvent.values())
+            for (let i = 0; i < group.length; i += BATCH)
+              await this.sendGroup(group.slice(i, i + BATCH));
+        }
+      } while (this.again);
+    } catch (error) {
+      this.deps.log(
+        `drain failed: ${error instanceof Error ? error.message : error}`
+      );
+    }
+  }
+
+  private arm(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    const at = outbox.nextDueAt();
+    if (at === null) return;
+    this.timer = setTimeout(
+      () => void this.kick(),
+      Math.max(1000, at - this.deps.now())
+    );
+    this.timer.unref?.();
+  }
+
+  private async sendGroup(rows: OutboxRow[]): Promise<void> {
+    // An earlier group in this drain found the relay unusable.
+    const down = this.unavailable();
+    if (down) {
+      for (const r of rows) outbox.markFailed(r.id, down);
+      for (const key of new Set(rows.map((r) => r.event_key)))
+        await this.settle(key);
+      return;
+    }
+    const sendable: {
+      row: OutboxRow;
+      token: string;
+      env: "production" | "sandbox";
+    }[] = [];
+    for (const row of rows) {
+      const push = getDevicePush(row.device_id);
+      if (!push) outbox.markFailed(row.id, "no push token", true);
+      else if (!APNS_TOKEN.test(push.token)) {
+        outbox.markFailed(row.id, "not an APNs token");
+        setDevicePushError(
+          row.device_id,
+          "the registered token isn't an APNs token"
+        );
+      } else sendable.push({ row, token: push.token, env: push.environment });
+    }
+    // The relay folds a repeated token into one result, so send each once.
+    const seen = new Set<string>();
+    const unique = sendable.filter((s) => {
+      const k = `${s.token.toLowerCase()}:${s.env}`;
+      if (seen.has(k)) {
+        outbox.markFailed(s.row.id, "duplicate token");
+        return false;
+      }
+      seen.add(k);
+      return true;
+    });
+    if (unique.length) {
+      const first = unique[0].row;
+      const answer = await this.deps.relay({
+        v: 1,
+        devices: unique.map((s) => ({ token: s.token, env: s.env })),
+        push_type: "alert",
+        priority: first.level === "passive" ? 5 : 10,
+        level: first.level,
+        ...(first.collapse_id && { collapse_id: first.collapse_id }),
+        thread_id: first.category,
+        payload: JSON.parse(first.payload),
+      });
+      await this.apply(
+        unique.map((s) => s.row),
+        answer
+      );
+    }
+    for (const key of new Set(rows.map((r) => r.event_key)))
+      await this.settle(key);
+  }
+
+  private async apply(rows: OutboxRow[], answer: RelayAnswer): Promise<void> {
+    const now = this.deps.now();
+    if (answer.kind === "unavailable") {
+      this.down = { until: now + UNAVAILABLE_MS, reason: answer.reason };
+      this.deps.log(`push unavailable: ${answer.reason}`);
+      for (const r of rows) {
+        outbox.markFailed(r.id, answer.reason);
+        setDevicePushError(r.device_id, answer.reason);
+      }
+      for (const key of outbox.failPending(answer.reason))
+        await this.settle(key);
+      return;
+    }
+    if (answer.kind === "invalid") {
+      for (const r of rows) {
+        outbox.markFailed(r.id, answer.reason);
+        setDevicePushError(r.device_id, answer.reason);
+      }
+      return;
+    }
+    rows.forEach((r, i) => {
+      if (answer.kind === "retry")
+        return this.retry(r, now, answer.reason, answer.afterMs);
+      const res = answer.results[i];
+      if (!res) return this.retry(r, now, "no answer for this device");
+      if (res.status === "sent") {
+        outbox.markSent(r.id, now);
+        setDevicePushError(r.device_id, null);
+      } else if (res.status === "gone" || res.prune) {
+        const why = `token no longer valid${res.reason ? ` (${res.reason})` : ""}`;
+        pruneDevicePush(r.device_id, why);
+        outbox.markFailed(r.id, why, true);
+      } else if (res.status === "retry") {
+        this.retry(
+          r,
+          now,
+          res.reason ?? "try again",
+          res.retry_after ? res.retry_after * 1000 : undefined
+        );
+      } else {
+        const why = res.reason ?? "rejected";
+        outbox.markFailed(r.id, why);
+        setDevicePushError(r.device_id, why);
+      }
+    });
+  }
+
+  private retry(
+    r: OutboxRow,
+    now: number,
+    why: string,
+    afterMs?: number
+  ): void {
+    const max = isTestKey(r.event_key) ? 1 : MAX_ATTEMPTS;
+    if (r.attempts >= max) {
+      outbox.markFailed(r.id, why);
+      setDevicePushError(r.device_id, why);
+      return;
+    }
+    const wait = Math.min(
+      Math.max(BACKOFF_MS[r.attempts - 1] ?? BACKOFF_MS.at(-1)!, afterMs ?? 0),
+      MAX_BACKOFF_MS
+    );
+    outbox.markRetry(r.id, now + wait, why);
+  }
+
+  /** Once an event has ended with no phone reached, the held text goes by Telegram. */
+  private async settle(eventKey: string): Promise<void> {
+    const held = outbox.claimFallback(eventKey);
+    if (!held) return;
+    try {
+      await this.deps.fallback(held.source, held.text);
+    } catch (error) {
+      this.deps.log(
+        `fallback for ${held.source} didn't send: ${error instanceof Error ? error.message : error}`
+      );
+    }
+  }
+}

package/lib/notify/push/testing.ts

@@ -0,0 +1,30 @@
+// Test fixtures for the push sender: paired phones with push tokens.
+
+import crypto from "crypto";
+import { db } from "../../db";
+import { mintDevice, setDevicePush } from "@/lib/security/devices";
+import type { PushCategory } from "../push-types";
+
+export function pairPhone(categories?: PushCategory[]): string {
+  const { device } = mintDevice("phone");
+  setDevicePush(device.id, {
+    token: crypto.randomBytes(32).toString("hex"),
+    platform: "ios",
+    environment: "production",
+    categories,
+  });
+  return device.id;
+}
+
+export function resetPush(): void {
+  db.prepare(`DELETE FROM push_outbox`).run();
+  db.prepare(`DELETE FROM devices`).run();
+  const g = globalThis as { __agentosPush?: { dispose(): void } };
+  g.__agentosPush?.dispose();
+  g.__agentosPush = undefined;
+}
+
+export const outboxRows = (where = "1=1") =>
+  db
+    .prepare(`SELECT * FROM push_outbox WHERE ${where} ORDER BY id`)
+    .all() as import("./outbox").OutboxRow[];

package/lib/notify/push/waiting.ts

@@ -0,0 +1,29 @@
+/**
+ * "Needs you" is a session that has waited on Saad for a minute. A timer
+ * starts when it begins waiting and is cancelled by any change, so a quick
+ * permission prompt that he answers never buzzes.
+ */
+
+import { pushNeedsYou } from "./events";
+import { WAIT_MS } from "./policy";
+
+const timers = new Map<string, ReturnType<typeof setTimeout>>();
+
+export function noteWaiting(sessionId: string, waiting: boolean): void {
+  const armed = timers.get(sessionId);
+  if (!waiting) {
+    if (armed) {
+      clearTimeout(armed);
+      timers.delete(sessionId);
+    }
+    return;
+  }
+  if (armed) return;
+  const armedAt = Date.now();
+  const timer = setTimeout(() => {
+    timers.delete(sessionId);
+    pushNeedsYou(sessionId, armedAt);
+  }, WAIT_MS);
+  timer.unref?.();
+  timers.set(sessionId, timer);
+}

package/lib/notify/push-types.ts

@@ -74,4 +74,6 @@ export interface PushEvent {
   id?: string | null;
   /** Dedupe key, e.g. `ask:<id>` or `review:<task>:<sha>`. */
   key?: string | null;
+  /** Events sharing this replace each other on the phone. Defaults to key. */
+  collapse?: string | null;
 }

package/lib/notify/redact.ts

@@ -16,6 +16,17 @@ const SECRET_PATTERNS: RegExp[] = [
   /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g,
 ];
 
+/**
+ * An id or key made by the app: no known token shape, and no single
+ * segment (split on - _ : .) that is a long hex or base64 run. A uuid or a
+ * timestamped id passes; a pasted key or a 40-character sha does not.
+ */
+function plainIdent(text: string): boolean {
+  if (SECRET_PATTERNS.some((re) => ((re.lastIndex = 0), re.test(text))))
+    return false;
+  return !text.split(/[-_:.]/).some((seg) => seg.length >= 24);
+}
+
 /** True when the string looks like a token, key or JWT. */
 export function looksSecret(text: string): boolean {
   return [...SECRET_PATTERNS, LONG_RUN].some((re) => {
@@ -42,7 +53,7 @@ export function safeId(id: unknown): string | null {
   if (typeof id !== "string" || id.length === 0 || id.length > MAX_ID)
     return null;
   if (!SAFE_ID.test(id)) return null;
-  return looksSecret(id) ? null : id;
+  return plainIdent(id) ? id : null;
 }
 
 /**
@@ -53,5 +64,5 @@ export function safeKey(key: unknown): string | null {
   if (typeof key !== "string" || key.length === 0 || key.length > 128)
     return null;
   if (!/^[A-Za-z0-9_:.-]+$/.test(key)) return null;
-  return looksSecret(key) ? null : key;
+  return plainIdent(key) ? key : null;
 }

package/lib/orchestrator/act.ts

@@ -19,7 +19,9 @@ import {
   launchSession,
   type StartView,
 } from "../sessions/launch";
-import { createTask, dropTask } from "../tasks";
+import { assertMovable, createTask, dropTask, moveTask } from "../tasks";
+import { getHost, hostIdNamed } from "../hosts";
+import { queueEvent } from "./events";
 import {
   findQueued,
   queuedLabel,
@@ -280,3 +282,41 @@ export async function done(workspaceId: string, ref: string): Promise<string> {
 export async function stop(workspaceId: string, ref: string): Promise<string> {
   return stopSession(findWorkspaceSession(workspaceId, ref));
 }
+
+// Carries a task to a linked machine, or back ("here"): heavy test or build
+// work can run on the box. The move takes minutes, so it runs in the
+// background; the orchestrator is told when the task lands or doesn't.
+// Everything about the task (gates, events, read/send/stop/drop) is the same
+// wherever it runs; the machine it lands on holds it for this one.
+export async function moveTaskTo(
+  workspaceId: string,
+  ref: string,
+  machine: string
+): Promise<string> {
+  const task = workspaceTask(workspaceId, ref);
+  const hostId = hostIdNamed(machine);
+  assertMovable(task.id, hostId);
+  const where = hostId === "local" ? "this machine" : machineName(hostId);
+  void moveTask(task.id, hostId).then(
+    (moved) => {
+      addNote(workspaceId, `Moved task ${task.name} to ${where}.`);
+      queueEvent(
+        workspaceId,
+        `move:${moved.id}:${Date.now()}`,
+        moved.id,
+        `Task ${task.name} now runs on ${where}.`
+      );
+    },
+    (error) =>
+      queueEvent(
+        workspaceId,
+        `move-failed:${task.id}:${Date.now()}`,
+        task.id,
+        `Moving task ${task.name} to ${where} failed: ${error instanceof Error ? error.message : String(error)}. It carries on where it was unless it says it's paused as "moving".`
+      )
+  );
+  return `Moving ${task.name} to ${where}. It takes a few minutes; an event tells you when it runs there.`;
+}
+
+const machineName = (hostId: string) =>
+  getHost(hostId)?.name ?? "the other machine";

package/lib/orchestrator/armed.ts

@@ -58,7 +58,8 @@ function armedTasks(workspaceId: string): Session[] {
     .prepare(
       `SELECT s.* FROM sessions s JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.merge_armed_at IS NOT NULL
-         AND s.task_status = 'running' AND s.peer_mirror = 0`
+         AND s.task_status = 'running' AND s.peer_mirror = 0
+         AND s.held_by_device IS NULL`
     )
     .all(workspaceId) as Session[];
 }
@@ -100,6 +101,10 @@ export function armTask(task: Session): void {
     );
   if (task.peer_mirror)
     throw new Error(`${task.name} runs on a linked machine; arm it there`);
+  if (task.held_by_device)
+    throw new Error(
+      `${task.name} is held for ${task.held_from ?? "another machine"}'s orchestrator; it arms it there`
+    );
   if (!armingWorkspace(task))
     throw new Error(
       `${task.name}'s project isn't in a workspace with an orchestrator, which an armed merge reports to`

package/lib/orchestrator/asks.ts

@@ -6,6 +6,7 @@
  * gate or brake ask is spent on that one item: never standing permission.
  */
 
+import { pushAskRaised } from "../notify/push/events";
 import { db } from "../db";
 import { answerKey, queueEvent } from "./events";
 import { addNote } from "./notes";
@@ -167,7 +168,7 @@ export function raiseAsk(input: {
   const sha = input.sha ?? null;
   const brakeKey = input.brakeKey ?? null;
   const raisedBy = input.raisedBy ?? null;
-  return db.transaction(() => {
+  const result = db.transaction(() => {
     const open = openBySubject(input.workspaceId, input.subject);
     if (open) {
       db.prepare(
@@ -209,6 +210,9 @@ export function raiseAsk(input: {
       created: true,
     };
   })();
+  // A new ask buzzes the phone; a refresh of an open one doesn't.
+  if (result.created) pushAskRaised(result.ask.id, input.workspaceId);
+  return result;
 }
 
 export function openAsks(workspaceId: string): AskRow[] {

package/lib/orchestrator/brakes.ts

@@ -74,6 +74,15 @@ export async function runningCount(
             "running";
     if (busy) running.add(s.id);
   }
+  // A task mid-move is out of the list above, but it runs again within
+  // minutes, here or there: it holds its slot.
+  const moving = db
+    .prepare(
+      `SELECT s.id FROM sessions s JOIN projects p ON p.id = s.project_id
+       WHERE p.workspace_id = ? AND s.task_status = 'moving' AND s.peer_mirror = 0`
+    )
+    .all(workspaceId) as { id: string }[];
+  for (const { id } of moving) running.add(id);
   for (const { target } of startsSince(workspaceId, now - WARMUP_MS))
     if (target) running.add(target);
   return running.size;

package/lib/orchestrator/brief.ts

@@ -109,7 +109,8 @@ Acting:
 - \`${TOOL_NAMES.quick_pr}\` (change, title, body): commit everything in a quick change, push its branch (never the default branch) and open its PR, or push to the PR it has; its review starts at once. Then it's gated like any task: CI, that review (also its code-review gate), scope, then sign_off or arm. It's in \`sessions\` as your quick change; drop it to throw it away, and it's cleaned up like a task when it merges or is dropped.
 - \`${TOOL_NAMES.stack}\` (target, plan_only?): run a board's open cards as stacked tasks; plan_only shows the plan without starting.
 - \`${TOOL_NAMES.land}\` (id): merge a stack bottom-up through the gates.
-- \`${TOOL_NAMES.drop}\` (task, reason): close a task's PR and remove its worktree.
+- \`${TOOL_NAMES.move}\` (task, machine): carry a running task to a linked machine (heavy test or build work), or back with machine "here". It keeps its branch, conversation and plan, and everything you do with a task works the same there: its events come to you, read, send, stop, done and drop reach it, and the gates judge its PR at its head. The machine it lands on holds it for you and can't merge it. It runs in the background; an event says when it lands. Refused while paused, and for a task waiting on Saad.
+- \`${TOOL_NAMES.drop}\` (task, reason): close a task's PR and remove its worktree (on whichever machine holds it).
 - \`${TOOL_NAMES.stop}\` (session): stop a session's agent, keeping its work.
 - \`${TOOL_NAMES.done}\` (session): finish a session whose work is complete. A task with an open PR merges through the same gates as sign_off first (refused naming the gate otherwise); then the agent stops, the worktree goes only if nothing in it would be lost, and the session is archived out of view. Not a rejection: use drop for that.
 - \`${TOOL_NAMES.add_project}\` (path, name?): make a git repository on this machine a project of this workspace, or move the project already at that path in when it's in no workspace. Use it rather than sending Saad steps. It refuses a folder that isn't a git repository or holds secrets, and a project another workspace has: moving that is Saad's call, so ask_saad.

package/lib/orchestrator/facts.ts

@@ -7,7 +7,7 @@
 
 import { db, type Session, type StackItemStatus } from "../db";
 import { statusDetector } from "../status-detector";
-import { hostLink } from "../hosts/remote-api";
+import { cleanRemoteText, hostLink } from "../hosts/remote-api";
 import { peerStatus } from "../hosts/peer-sessions";
 import { chatCompacting, chatState } from "../chat/runner";
 import { chatActivityLine, chatStall, type Stall } from "../chat/activity";
@@ -16,11 +16,16 @@ import { needsYou } from "../needs-you";
 import { programSummary } from "../program-status/store";
 import { sessionRowInfo } from "../session-meta";
 import { taskView, type TaskPR, type TaskState } from "../tasks";
-import { storedPR } from "../tasks/session";
+import { prFor, storedPR } from "../tasks/session";
+import { lastActiveOf } from "../tasks/last-active";
+import { hostTasks } from "../tasks/remote";
+import { deriveTaskState } from "../tasks";
+import { waitingState } from "./task-state";
 import { commitTime, repoOf } from "./repo";
 import { CHECKLESS_MS, checklessFor, ciSettleIn } from "./task-state";
 import { repoHasCI } from "./repo-ci";
 import { markStatusDirty } from "../status/dirty";
+import { queueEvent } from "./events";
 
 export type FactStatus = "running" | "waiting" | "idle" | "dead";
 
@@ -68,9 +73,6 @@ export interface SessionFacts {
   } | null;
 }
 
-const sqliteMs = (t: string | null | undefined) =>
-  t ? Date.parse(`${t.replace(" ", "T")}Z`) || 0 : 0;
-
 // Live sessions in the workspace's projects, plus tasks merged in the last
 // hour so their merge still reads. Never an orchestrator or an archived one.
 export function workspaceSessions(
@@ -83,6 +85,8 @@ export function workspaceSessions(
        WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
          -- A linked machine's own sessions are its orchestrator's to run.
          AND s.peer_mirror = 0
+         -- A task another machine's orchestrator moved here is held for it.
+         AND s.held_by_device IS NULL
          AND (s.task_status IS NULL OR s.task_status = 'running'
            OR (s.task_status = 'merged' AND s.updated_at > datetime('now', '-1 hour')))
        ORDER BY s.created_at`
@@ -121,17 +125,6 @@ function stackOf(sessionId: string): SessionFacts["stack"] {
   };
 }
 
-function latestChatAt(sessionId: string): number {
-  const row = db
-    .prepare(
-      `SELECT data FROM chat_items WHERE session_id = ? ORDER BY seq DESC LIMIT 1`
-    )
-    .get(sessionId) as { data: string } | undefined;
-  return row
-    ? ((JSON.parse(row.data) as { createdAt?: number }).createdAt ?? 0)
-    : 0;
-}
-
 export async function statusOf(s: Session): Promise<{
   status: FactStatus;
   activity: string | null;
@@ -251,6 +244,7 @@ async function taskFacts(
     const state = s.task_status === "moved" ? "done" : s.task_status;
     return { state, pr, blocked: null };
   }
+  if (hostLink(s.host_id)) return remoteTaskFacts(workspaceId, s);
   const view = await taskView(s);
   return {
     state: view.state,
@@ -261,6 +255,67 @@ async function taskFacts(
   };
 }
 
+// A task another machine runs: its state is that machine's word (the same
+// reading the gates use), and the PR is read here, from GitHub, by branch.
+// What it can't say reads as blocked, never as clear.
+async function remoteTaskFacts(
+  workspaceId: string,
+  s: Session
+): Promise<NonNullable<SessionFacts["task"]>> {
+  const [pr, waiting] = await Promise.all([
+    prFor(s).catch(() => null),
+    waitingState(s),
+  ]);
+  await announceRemotePlan(workspaceId, s);
+  const status = peerStatus(s.host_id, s.id) ?? "running";
+  const state = deriveTaskState({
+    taskStatus: "running",
+    sessionStatus: status,
+    pr,
+    blocked: waiting.blocked !== null,
+  });
+  return {
+    state,
+    pr,
+    blocked: waiting.blocked,
+    ciSettleIn: await settleIn(workspaceId, s, pr),
+    ciSilentMs: await silentFor(s, pr),
+  };
+}
+
+// The plan-written line a held task stored on its machine (plan-step.ts),
+// once per distinct plan: the mirror keeps the last one it told about.
+async function announceRemotePlan(
+  workspaceId: string,
+  s: Session
+): Promise<void> {
+  const link = hostLink(s.host_id);
+  if (!link) return;
+  const view = await hostTasks(link)
+    .then(({ tasks }) => tasks.find((t) => t?.id === s.id))
+    .catch(() => undefined);
+  const note =
+    typeof view?.planNote === "string"
+      ? cleanRemoteText(view.planNote).slice(0, 2000)
+      : "";
+  if (!note || note === s.plan_note) return;
+  db.prepare(`UPDATE sessions SET plan_note = ? WHERE id = ?`).run(note, s.id);
+  queueEvent(workspaceId, `plan-done:${s.id}`, s.id, note);
+}
+
+// A task on another machine is as active as that machine says; one it can't
+// reach is taken as active just now, so nothing reads it as abandoned.
+async function lastActiveFor(s: Session): Promise<number> {
+  const link = hostLink(s.host_id);
+  if (!link) return lastActiveOf(s);
+  const view = await hostTasks(link)
+    .then(({ tasks }) => tasks.find((t) => t?.id === s.id))
+    .catch(() => undefined);
+  return typeof view?.lastActiveAt === "number"
+    ? view.lastActiveAt
+    : Date.now();
+}
+
 export async function sessionFacts(
   workspaceId: string
 ): Promise<SessionFacts[]> {
@@ -283,11 +338,7 @@ export async function sessionFacts(
           s.view === "chat" && !hostLink(s.host_id) ? chatStall(s.id) : null,
         compacting:
           s.view === "chat" && !hostLink(s.host_id) && !!chatCompacting(s.id),
-        lastActive: Math.max(
-          sqliteMs(s.updated_at),
-          statusDetector.getTimestamp(s.tmux_name) * 1000,
-          latestChatAt(s.id)
-        ),
+        lastActive: await lastActiveFor(s),
         branch: s.branch_name,
         quick: !!s.quick_of,
         plan: