@saadnvd1/agent-os 0.3.516 → 0.3.518

package/lib/tasks/index.ts

@@ -58,11 +58,12 @@ import { remoteTaskViews } from "./remote-views";
 import { chatStateNow } from "../chat/runner";
 import { saidSinceLastMessage } from "../chat/store";
 
+import { lastActiveOf } from "./last-active";
 export * from "./state";
 export { codeReviewGate, codeReviewRefusal } from "./code-review";
 export { signOffTask, dropTask, signingOff, mergeSettled } from "./finish";
 export { prFor as taskPR } from "./session";
-export { moveTask } from "./move-flow";
+export { assertMovable, moveTask } from "./move-flow";
 
 export interface TaskView {
   id: string;
@@ -106,6 +107,12 @@ export interface TaskView {
   quickOf?: string | null;
   // What it has cost so far in weighted tokens (lib/usage/weights).
   weighted?: number;
+  // Its last sign of life, in ms, for an orchestrator on another machine.
+  lastActiveAt?: number;
+  // Held for another machine's orchestrator (held.ts): which machine, and
+  // the "plan written" line it would have been told.
+  heldFrom?: string | null;
+  planNote?: string | null;
 }
 
 export async function createTask(opts: {
@@ -394,6 +401,9 @@ export async function taskView(session: Session): Promise<TaskView> {
     planning: session.plan_phase === "planning",
     plan: taskPlan(session),
     quickOf: session.quick_of ?? null,
+    lastActiveAt: session.held_by_device ? lastActiveOf(session) : undefined,
+    heldFrom: session.held_by_device ? (session.held_from ?? null) : null,
+    planNote: session.held_by_device ? (session.plan_note ?? null) : null,
   };
 }
 

package/lib/tasks/last-active.ts

@@ -0,0 +1,25 @@
+// A session's last sign of life, in ms: its row, its tmux pane, its chat.
+
+import { db, type Session } from "../db";
+import { statusDetector } from "../status-detector";
+
+export const sqliteMs = (t: string | null | undefined) =>
+  t ? Date.parse(`${t.replace(" ", "T")}Z`) || 0 : 0;
+
+export 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 const lastActiveOf = (s: Session): number =>
+  Math.max(
+    sqliteMs(s.updated_at),
+    statusDetector.getTimestamp(s.tmux_name) * 1000,
+    latestChatAt(s.id)
+  );

package/lib/tasks/move-bundle.ts

@@ -14,8 +14,10 @@ export const MAX_TRANSCRIPT_BYTES = 64 * 1024 * 1024;
 // whole bundle stays under what a linked machine reads of an answer
 // (lib/hosts/remote-api), since a move back here reads it as one.
 export const MAX_CHAT_BYTES = 12 * 1024 * 1024;
+// A task's plan file is a page or two; this is far past that.
+export const MAX_PLAN_BYTES = 1024 * 1024;
 export const MAX_BUNDLE_BYTES =
-  MAX_TRANSCRIPT_BYTES + MAX_CHAT_BYTES + 1024 * 1024;
+  MAX_TRANSCRIPT_BYTES + MAX_CHAT_BYTES + MAX_PLAN_BYTES + 1024 * 1024;
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 export const isSessionId = (id: unknown): id is string =>
@@ -50,6 +52,25 @@ export interface TaskBundle {
   // A chat task's own state; absent for a terminal task, or from a machine
   // that predates chat moves.
   chat?: ChatBundle;
+  // What a task started by an orchestrator carries besides its work; absent
+  // for any other task, or from a machine that predates these moves.
+  orchestrated?: OrchestratedBundle;
+}
+
+export interface OrchestratedBundle {
+  // The machine whose orchestrator holds the task, for the other machine's
+  // screens and refusals.
+  heldFrom: string;
+  // When the task first started (an ISO time), so a PR opened before the
+  // move still counts as the task's.
+  since: string | null;
+  // The model's provider and a task's own models, as they were; an arriving
+  // machine without that provider refuses the task rather than change it.
+  modelProvider: string | null;
+  modelOverrides: string | null;
+  planPhase: "planning" | "implementing" | null;
+  // .agentos/plan.md, which is never in git.
+  planFile: string | null;
 }
 
 export interface ChatBundle {
@@ -101,6 +122,34 @@ function validateChat(c: ChatBundle): ChatBundle {
   return { ...c, plan: !!c.plan };
 }
 
+const PHASES = ["planning", "implementing"];
+
+function validateOrchestrated(o: OrchestratedBundle): OrchestratedBundle {
+  if (!o || typeof o !== "object") throw new Error("Bad orchestrated task");
+  if (
+    !isStrOrNull(o.since) ||
+    !isStrOrNull(o.modelProvider) ||
+    !isStrOrNull(o.modelOverrides) ||
+    !isStrOrNull(o.planFile) ||
+    !(o.planPhase === null || PHASES.includes(o.planPhase as string))
+  )
+    throw new Error("Bad orchestrated task");
+  if (o.since !== null && Number.isNaN(Date.parse(o.since)))
+    throw new Error("Bad start time");
+  if ((o.planFile?.length ?? 0) > MAX_PLAN_BYTES)
+    throw new Error("The plan is too large to move");
+  return {
+    heldFrom: String(o.heldFrom || "another machine")
+      .replace(/[^\w.@ -]/g, "")
+      .slice(0, 100),
+    since: o.since,
+    modelProvider: o.modelProvider,
+    modelOverrides: o.modelOverrides,
+    planPhase: o.planPhase,
+    planFile: o.planFile,
+  };
+}
+
 export function validateBundle(b: TaskBundle): TaskBundle {
   if (!b || typeof b !== "object") throw new Error("No task to import");
   if (!isSessionId(b.moveId)) throw new Error("Bad move id");
@@ -130,6 +179,9 @@ export function validateBundle(b: TaskBundle): TaskBundle {
   }
   return {
     ...b,
+    orchestrated: b.orchestrated
+      ? validateOrchestrated(b.orchestrated)
+      : undefined,
     chat: b.chat ? validateChat(b.chat) : undefined,
     name: b.name.slice(0, 200),
     from: String(b.from || "another machine")

package/lib/tasks/move-carry.ts

@@ -0,0 +1,102 @@
+/**
+ * An orchestrator's state about a task is keyed by the task's session id, and
+ * a move gives the task a new one on each machine. Carrying re-keys that state
+ * from the old id to the new, inside the transaction that makes the new row,
+ * so the gates, failure counts, asks, scope changes and events judge the task
+ * the same after a move. move-carry.test.ts fails on any table that keys by a
+ * session and is in neither list, so a new one gets decided.
+ */
+
+import type Database from "better-sqlite3";
+import { db } from "../db";
+
+// table, column, and how the id sits in it: the whole value, `task:<id>`, or
+// the tail of a `<condition>:<id>` key.
+export const REKEYED = [
+  ["orchestrator_starts", "target", "id"],
+  ["orchestrator_checks", "session_id", "id"],
+  ["orchestrator_gate_failures", "session_id", "id"],
+  ["orchestrator_gate_failure_commits", "session_id", "id"],
+  ["orchestrator_asks", "subject", "task"],
+  ["brief_amendments", "session_id", "id"],
+  ["task_pr_wakes", "session_id", "id"],
+  ["orchestrator_events", "subject", "id"],
+  ["orchestrator_events", "key", "tail"],
+  ["check_runs", "session_id", "id"],
+  ["away_actions", "subject", "task"],
+  ["task_queue", "after_task", "id"],
+] as const;
+
+// Session-keyed columns that stay on the old id, and why.
+export const KEPT = [
+  ["orchestrator_event_log", "subject", "history is never rewritten"],
+  ["stack_items", "session_id", "stacked tasks don't move"],
+  [
+    "task_queue",
+    "after_any",
+    "a JSON list; a queued task waits on any of them",
+  ],
+] as const;
+
+// Copied onto the new row where it has no value.
+export const CARRIED_COLUMNS = [
+  "started_by",
+  "plan_decided",
+  "plan_reason",
+  "plan_phase",
+  "model_provider",
+  "model_overrides",
+  "merge_armed_at",
+  "merge_armed_seen",
+  "rebased_from",
+  "rebased_to",
+  "rebase_asked_head",
+  "pr_wake_since",
+  "pr_url",
+  "pr_number",
+  "pr_status",
+] as const;
+
+/** The orchestration columns that make a session "an orchestrator's task". */
+export const orchestrationOf = (session: Record<string, unknown>) =>
+  Object.fromEntries(
+    CARRIED_COLUMNS.map((c) => [c, session[c] ?? null] as const)
+  );
+
+export function carryTaskState(
+  fromId: string,
+  toId: string,
+  handle: Database.Database = db
+): void {
+  if (fromId === toId) return;
+  for (const [table, col, shape] of REKEYED) {
+    if (shape === "id")
+      handle
+        .prepare(`UPDATE ${table} SET ${col} = ? WHERE ${col} = ?`)
+        .run(toId, fromId);
+    else if (shape === "task")
+      handle
+        .prepare(`UPDATE ${table} SET ${col} = ? WHERE ${col} = ?`)
+        .run(`task:${toId}`, `task:${fromId}`);
+    else
+      handle
+        .prepare(
+          `UPDATE OR IGNORE ${table}
+             SET ${col} = substr(${col}, 1, length(${col}) - ?) || ?
+             WHERE ${col} LIKE ?`
+        )
+        .run(fromId.length, toId, `%:${fromId}`);
+  }
+  const from = handle
+    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .get(fromId) as Record<string, unknown> | undefined;
+  if (!from) return;
+  const sets = [...CARRIED_COLUMNS, "task_since"]
+    .map((c) => `${c} = COALESCE(${c}, @${c})`)
+    .join(", ");
+  handle.prepare(`UPDATE sessions SET ${sets} WHERE id = @id`).run({
+    ...orchestrationOf(from),
+    task_since: (from.task_since as string | null) ?? from.created_at ?? null,
+    id: toId,
+  });
+}

package/lib/tasks/move-flow.ts

@@ -11,7 +11,10 @@ import { isRemoteHost } from "../hosts";
 import { requireHostLink, type HostLink } from "../hosts/remote-api";
 import { getTaskSession } from "./session";
 import { exportOrResume, markMoved, resumeTask, type TaskBundle } from "./move";
-import { moveRefusal } from "./move-guard";
+import { isOrchestrated, moveRefusal } from "./move-guard";
+import { holderRefusal } from "./held";
+import { isPaused } from "../orchestrator/pause";
+import { sessionWorkspace } from "../models/resolve";
 import { arrived as arrivedHere, importTask } from "./import";
 import {
   forgetHostTasks,
@@ -34,7 +37,8 @@ const LIVE = new Set(["running", "moving"]);
 const g = globalThis as unknown as { __agentosMovesInFlight?: Set<string> };
 const inFlight = (g.__agentosMovesInFlight ??= new Set());
 
-export async function moveTask(id: string, toHostId: string): Promise<Session> {
+/** Why this task can't move to that machine now, as an error; or nothing. */
+export function assertMovable(id: string, toHostId: string): Session {
   const session = getTaskSession(id);
   if (!LIVE.has(session.task_status ?? ""))
     throw new Error(`Task is already ${session.task_status}`);
@@ -47,9 +51,22 @@ export async function moveTask(id: string, toHostId: string): Promise<Session> {
         : "It's already on this machine"
     );
   }
+  // A person here can't move what another machine's orchestrator holds.
+  const held = holderRefusal(session, null);
+  if (held) throw new Error(held);
   const refusal = moveRefusal(session);
   if (refusal) throw new Error(refusal);
+  // Pause stops the orchestrator's new work, and a move is some.
+  const workspace = sessionWorkspace(session);
+  if (workspace && isOrchestrated(session) && isPaused(workspace))
+    throw new Error("The orchestrator is paused; moves wait for Resume");
   if (inFlight.has(id)) throw new Error("It's already moving");
+  return session;
+}
+
+export async function moveTask(id: string, toHostId: string): Promise<Session> {
+  const session = assertMovable(id, toHostId);
+  const toRemote = isRemoteHost(toHostId);
   inFlight.add(id);
   try {
     const moved = toRemote
@@ -66,19 +83,27 @@ export async function moveTask(id: string, toHostId: string): Promise<Session> {
 }
 
 // A machine on an older AgentOS would take a chat task as a terminal one,
-// or refuse to hand one over.
-async function requireChatMoves(link: HostLink): Promise<void> {
+// or an orchestrator's task as a plain one that anyone there could merge, or
+// refuse to hand one over.
+async function requireCapability(
+  link: HostLink,
+  capability: string,
+  what: string
+): Promise<void> {
   const { capabilities = [] } = await hostTasks(link, true).catch((err) => {
     throw new Error(
-      `Can't ask ${link.hostName} whether it takes chat tasks: ${(err as Error).message}`
+      `Can't ask ${link.hostName} whether it takes ${what}: ${(err as Error).message}`
     );
   });
-  if (!capabilities.includes("chat-move"))
+  if (!capabilities.includes(capability))
     throw new Error(
-      `${link.hostName}'s AgentOS can't move chat tasks yet; update it first`
+      `${link.hostName}'s AgentOS can't move ${what} yet; update it first`
     );
 }
 
+const requireChatMoves = (link: HostLink) =>
+  requireCapability(link, "chat-move", "chat tasks");
+
 const unconfirmed = (where: string, err: unknown) =>
   new Error(
     `Couldn't confirm the move with ${where} (${(err as Error).message}). It's paused as "moving": press Move again to finish it.`
@@ -88,6 +113,8 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
   const link = requireHostLink(hostId);
   const chat = session.view === "chat";
   if (chat) await requireChatMoves(link);
+  if (isOrchestrated(session))
+    await requireCapability(link, "orchestrated-move", "orchestrator tasks");
   startProgress(
     session.id,
     link.hostName,

package/lib/tasks/move-guard.ts

@@ -1,13 +1,24 @@
 /**
  * Tasks that can't move: one waiting on a person (an escalated gate or an
- * open ask), on a LumifyHub card, in a stack, or started by an orchestrator
- * (its brakes, ceiling and Pause count only what runs here). Their guard state is keyed
- * by this session and wouldn't follow it, so the other machine could merge
- * what's waiting on them.
+ * open ask), on a LumifyHub card, or in a stack. A task an orchestrator
+ * started does move: its state is re-keyed to the new session (move-carry),
+ * and the machine it lands on holds it for that orchestrator's device
+ * (held.ts), so nothing there merges it.
  */
 
 import { db, type Session } from "../db";
 import { escalations } from "../orchestrator/gates";
+import { taskSubject } from "../orchestrator/asks";
+
+/** Started by an orchestrator, or held for one by the machine it left. */
+export function isOrchestrated(session: Session): boolean {
+  if (session.started_by || session.held_by_device) return true;
+  return !!db
+    .prepare(
+      `SELECT 1 FROM orchestrator_starts WHERE kind != 'stack' AND target = ? LIMIT 1`
+    )
+    .get(session.id);
+}
 
 export function moveRefusal(session: Session): string | null {
   if (session.quick_of)
@@ -16,9 +27,9 @@ export function moveRefusal(session: Session): string | null {
     return "It's waiting on you (an escalated gate), so it stays here";
   const ask = db
     .prepare(
-      `SELECT 1 FROM orchestrator_asks WHERE subject = ? AND status = 'open' LIMIT 1`
+      `SELECT 1 FROM orchestrator_asks WHERE subject IN (?, ?) AND status = 'open' LIMIT 1`
     )
-    .get(session.id);
+    .get(session.id, taskSubject(session.id));
   if (ask) return "It has an open ask waiting on you, so it stays here";
   const row = db
     .prepare(
@@ -31,12 +42,5 @@ export function moveRefusal(session: Session): string | null {
     | undefined;
   if (row?.lh_card_id) return "Card tasks run on this machine only for now";
   if (row?.stacked) return "Stacked tasks run on this machine only for now";
-  const orchestrated = db
-    .prepare(
-      `SELECT 1 FROM orchestrator_starts WHERE kind != 'stack' AND target = ? LIMIT 1`
-    )
-    .get(session.id);
-  if (orchestrated)
-    return "An orchestrator's tasks run on this machine only for now";
   return null;
 }

package/lib/tasks/move-recover.ts

@@ -12,6 +12,7 @@ import { hostApi, hostLink, type HostLink } from "../hosts/remote-api";
 import { getTaskSession } from "./session";
 import { markMoved, resumeTask } from "./move";
 import { forgetHostTasks, mirrorTask, unknownOutcome } from "./remote";
+import { carryTaskState } from "./move-carry";
 
 /** POST, repeated when the outcome is unknown (the calls are idempotent). */
 export async function tell(
@@ -50,6 +51,7 @@ export function settleMovedOut(
   db.transaction(() => {
     markMoved(session.id, hostName);
     mirrorTask(hostId, session.project_id, there);
+    carryTaskState(session.id, there.id);
   })();
   forgetHostTasks(hostId);
   return db

package/lib/tasks/move.ts

@@ -6,18 +6,26 @@
  * it off and a second move of it is refused.
  */
 
+import fs from "fs";
 import os from "os";
+import path from "path";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { endTmuxSession } from "../tmux/end";
 import { launchClaude } from "../agents/launch";
 import { buildTaskBrief } from "./brief";
 import { git as runGit } from "../git-exec";
-import { getTaskSession } from "./session";
+import { getTaskSession, isoUTC } from "./session";
 import { projectRef } from "./project-ref";
-import { moveRefusal } from "./move-guard";
-import { MAX_TRANSCRIPT_BYTES, type TaskBundle } from "./move-bundle";
+import { isOrchestrated, moveRefusal } from "./move-guard";
+import {
+  MAX_PLAN_BYTES,
+  MAX_TRANSCRIPT_BYTES,
+  type OrchestratedBundle,
+  type TaskBundle,
+} from "./move-bundle";
 import { stepProgress } from "./move-progress";
+import { PLAN_FILE } from "../models/plan-step";
 import { dropSessionDatabase } from "../project-config/database";
 import { releaseChat } from "../chat/runner";
 import { collectWhileMoving } from "../chat/hold";
@@ -98,6 +106,28 @@ function claimMoving(id: string, to: string): { fresh: boolean } {
 // Set by exportTask: did this call stop a running agent, or retry a move?
 const freshClaims = new Set<string>();
 
+const readPlanFile = (cwd: string): string | null => {
+  try {
+    const text = fs.readFileSync(path.join(cwd, PLAN_FILE), "utf8");
+    return text.length > MAX_PLAN_BYTES ? null : text;
+  } catch {
+    return null;
+  }
+};
+
+// What an orchestrator's task carries besides its work (the orchestrator's
+// own state is re-keyed here; see move-carry).
+function orchestratedBundle(session: Session): OrchestratedBundle {
+  return {
+    heldFrom: session.held_from || os.hostname(),
+    since: isoUTC(session.task_since ?? session.created_at),
+    modelProvider: session.model_provider ?? null,
+    modelOverrides: session.model_overrides ?? null,
+    planPhase: session.plan_phase ?? null,
+    planFile: readPlanFile(session.working_directory),
+  };
+}
+
 /**
  * Stops the agent and pushes everything. On failure the task stays moving;
  * the caller resumes it (exportOrResume) when it knows nothing arrived.
@@ -163,6 +193,7 @@ export async function exportTask(id: string, to: string): Promise<TaskBundle> {
           ? { sessionId: claudeId, cwd, home: os.homedir(), transcript }
           : null,
       chat: chatBundle,
+      orchestrated: isOrchestrated(now) ? orchestratedBundle(now) : undefined,
     };
   } finally {
     packed();

package/lib/tasks/remote.ts

@@ -27,6 +27,9 @@ export const TASK_CAPABILITIES = [
   "chat-turn",
   "keyed-start",
   "chat-move",
+  // Holds an orchestrator's task for the machine that sent it, and answers
+  // its messages, reads, stops and done (lib/tasks/held.ts).
+  "orchestrated-move",
 ] as const;
 
 export interface HostTasks {

package/lib/tasks/session.ts

@@ -16,6 +16,12 @@ import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
 import { lookupPR } from "./pr-poll";
 import { captureMergedTask } from "../session-logs";
+import { getOrchestrator } from "../orchestrator/home";
+import {
+  pushCiFailed,
+  pushMerged,
+  pushReviewReady,
+} from "../notify/push/events";
 import { notifyStatusChanged } from "../status/hub";
 import type { TaskPR } from "./state";
 import { markStatusDirty } from "../status/dirty";
@@ -164,7 +170,7 @@ export async function prFor(
   const branch = renamed ?? session.branch_name;
   if (!branch) return null;
   // A PR older than the task is an earlier use of the branch's name.
-  const since = isoUTC(session.created_at);
+  const since = isoUTC(session.task_since ?? session.created_at);
   let pr: TaskPR | null;
   if (renamed) {
     // Follow a rename only on gh's answer: a failure leaves the row put.
@@ -193,14 +199,19 @@ export async function prFor(
   prCache.set(session.id, { at: Date.now(), pr });
   markStatusDirty(session.id);
   // A PR whose stage inputs moved is news for the sidebar's badge.
-  if (prSignature(before) !== prSignature(pr)) notifyStatusChanged();
+  if (prSignature(before) !== prSignature(pr)) {
+    notifyStatusChanged();
+    if (pr) pushPrChange(session, pr);
+  }
   if (pr) {
     db.prepare(
       `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`
     ).run(pr.url, pr.number, pr.state.toLowerCase(), session.id);
     // Merged on GitHub rather than through AgentOS: its log is due too.
-    if (pr.state === "MERGED")
+    if (pr.state === "MERGED") {
+      if (session.pr_status !== "merged") pushMerged(session.id);
       void captureMergedTask(session.id, { head: pr.head });
+    }
   }
   // Only an answer just read from GitHub: a cached one may predate a
   // retarget AgentOS made itself (a restack).
@@ -283,3 +294,16 @@ export function forgetPR(sessionId: string): void {
   prCache.delete(sessionId);
   markStatusDirty(sessionId);
 }
+
+// CI failing is news for the phone in any workspace. Green is "ready for
+// review" only where no orchestrator runs a review of its own (its verdict is
+// the signal there). Each head is pushed once: the event key holds the sha.
+export function pushPrChange(session: Session, pr: TaskPR): void {
+  if (pr.state !== "OPEN" || !pr.head) return;
+  if (pr.checks === "fail") pushCiFailed(session.id, pr.head);
+  else if (
+    pr.checks === "pass" &&
+    !(session.workspace_id && getOrchestrator(session.workspace_id))
+  )
+    pushReviewReady(session.id, pr.head);
+}

package/package.json

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

package/server.ts

@@ -15,6 +15,7 @@ import { startOrchestratorWatcher } from "./lib/orchestrator/watcher";
 import { realDeps, schedulesEnabled, startScheduler } from "./lib/schedules";
 import { startUsageRollup, usageRollupEnabled } from "./lib/usage/nightly";
 import { resumePhoneOutbox } from "./lib/notify";
+import { resumePushOutbox } from "./lib/notify/push";
 import {
   bindAddresses,
   requestAllowed,
@@ -395,6 +396,7 @@ app.prepare().then(async () => {
   // Schedules tick here, once a minute, and nowhere else.
   if (schedulesEnabled(process.env)) startScheduler(realDeps);
   resumePhoneOutbox();
+  resumePushOutbox();
   // The usage ledger's daily rollup and its ratchet alerts.
   if (usageRollupEnabled(process.env)) startUsageRollup();
   // Machine load: a gauge, notes on heavy commands, one alert when red.