@saadnvd1/agent-os 0.3.631 → 0.3.639

package/lib/tasks/contract/sync.ts

@@ -0,0 +1,126 @@
+/**
+ * The one loop that brings this machine's mirrors in line with what their
+ * machines say. Each tick reads every machine's task list once and applies it
+ * to each mirror: finished and moved, a plan written, a plan note to tell the
+ * orchestrator about, an approved plan coming home. Nothing else polls a
+ * machine's tasks to write a mirror.
+ */
+
+import { db, type Session } from "../../db";
+import { isRemoteHost } from "../../hosts";
+import { hostLink, cleanRemoteText } from "../../hosts/remote-api";
+import { sessionWorkspace } from "../../models/resolve";
+import { queueEvent } from "../../orchestrator/events";
+import { orchestratorOf } from "../starter";
+import type { TaskStatus } from "../state";
+import type { TaskView } from "../index";
+import * as client from "./client";
+import {
+  finishArrival,
+  fire,
+  handingOff,
+  handoffHome,
+  planWritten,
+} from "./plan";
+import { setMirrorStatus } from "./start";
+import { setPlan } from "../../db/session-parts";
+
+const FINISHED: Record<string, TaskStatus> = {
+  merged: "merged",
+  dropped: "dropped",
+  done: "done",
+};
+
+const getSession = (id: string) =>
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+
+// 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.
+function announcePlanNote(s: Session, view: TaskView): void {
+  const workspaceId = sessionWorkspace(s);
+  if (!workspaceId || !orchestratorOf(s.started_by)) return;
+  const note =
+    typeof view.planNote === "string"
+      ? cleanRemoteText(view.planNote).slice(0, 2000)
+      : "";
+  if (!note || note === s.plan_note) return;
+  setPlan(db, s.id, { plan_note: note });
+  queueEvent(workspaceId, `plan-done:${s.id}`, s.id, note);
+}
+
+async function applyView(
+  s: Session,
+  view: TaskView | undefined,
+  gone: Set<string>
+): Promise<void> {
+  if (!view) {
+    if (gone.has(s.id)) setMirrorStatus(s.id, "moved");
+    return;
+  }
+  if (FINISHED[view.state]) {
+    setMirrorStatus(s.id, FINISHED[view.state]);
+    return;
+  }
+  if (!s.plan_waits_for_caller) return announcePlanNote(s, view);
+  if (s.plan_phase === "planning") await planWritten(s, view);
+  else if (s.plan_phase === "handoff") fire(s.id, () => handoffHome(s.id));
+}
+
+/** Every task this machine mirrors from a linked machine, that machine's word applied. */
+export async function syncMirrors(): Promise<void> {
+  const rows = (
+    db
+      .prepare(
+        `SELECT * FROM session_rows
+         WHERE task_prompt IS NOT NULL AND task_status = 'running'
+           AND archived_at IS NULL AND peer_mirror IS NOT 1
+           AND host_id IS NOT NULL`
+      )
+      .all() as Session[]
+  ).filter((s) => isRemoteHost(s.host_id));
+  const byHost = new Map<string, Session[]>();
+  for (const s of rows)
+    byHost.set(s.host_id, [...(byHost.get(s.host_id) ?? []), s]);
+  for (const [hostId, mirrors] of byHost) {
+    const link = hostLink(hostId);
+    if (!link) continue;
+    let listing: Awaited<ReturnType<typeof client.list>>;
+    try {
+      listing = await client.list(link);
+    } catch {
+      continue;
+    }
+    const live = new Map(
+      (Array.isArray(listing.tasks) ? listing.tasks : []).map((t) => [t?.id, t])
+    );
+    const gone = new Set((listing.moved ?? []).map((m) => m.id));
+    for (const s of mirrors) {
+      try {
+        await applyView(s, live.get(s.id), gone);
+      } catch (e) {
+        console.error(`Mirror of ${s.id} on ${hostId} failed:`, e);
+      }
+    }
+  }
+  // A task that arrived but never began implementing (a restart between).
+  const arrived = db
+    .prepare(
+      `SELECT id, plan_handoff_message FROM session_rows
+       WHERE plan_phase = 'awaiting' AND plan_handoff_message IS NOT NULL
+         AND task_status = 'running' AND archived_at IS NULL AND peer_mirror IS NOT 1`
+    )
+    .all() as { id: string; plan_handoff_message: string }[];
+  for (const a of arrived) {
+    if (isRemoteHost(getSession(a.id)?.host_id)) continue;
+    fire(a.id, async () => {
+      handingOff.add(a.id);
+      try {
+        await finishArrival(a.id, a.plan_handoff_message);
+      } finally {
+        handingOff.delete(a.id);
+      }
+    });
+  }
+}

package/lib/tasks/contract/types.ts

@@ -0,0 +1,41 @@
+import type { TaskView } from "../index";
+
+/**
+ * What this machine's task API does, for another machine deciding whether
+ * it can trust it with a pinned merge or a move; keyed-start: a session
+ * start takes a key, so it's safe to retry (lib/sessions/launch.ts).
+ */
+export const TASK_CAPABILITIES = [
+  "pinned-merge",
+  "move",
+  "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 (contract/authorize.ts).
+  "orchestrated-move",
+  // A held task's chat facts and its messages for its orchestrator.
+  "held-chat-facts",
+  "held-replies",
+  // A keyed start that carries an orchestrator's description holds the task
+  // for the device that sent it, as a move does (lib/tasks/held.ts).
+  "held-start",
+  // A plan placed here by another machine stops at the plan for that machine
+  // to decide what follows (contract/plan.ts).
+  "remote-plan",
+  // Every task route a peer calls checks the holder or starter the same way.
+  // compat: the shims marked "task-contract-1" in contract/ go once every
+  // linked machine reports this.
+  "task-contract-1",
+] as const;
+
+export interface HostTasks {
+  tasks: TaskView[];
+  moved?: { id: string; movedTo: string | null }[];
+  capabilities?: string[];
+}
+
+export interface ChatFacts {
+  blocked: string | null;
+  turn: string | null;
+}

package/lib/tasks/{remote-views.ts → contract/views.ts}

@@ -1,21 +1,15 @@
 /**
  * How tasks on other machines look here: each mirror's view as its machine
- * reports it. A mirror follows the machine's word: finished when it says
- * finished, moved when it says moved, never because it went missing once.
+ * reports it. Reading only: the sync loop (sync.ts) is what records that a
+ * mirror finished or moved, never because it went missing once.
  */
 
-import type { Session } from "../db";
-import { requireHostLink, type HostLink } from "../hosts/remote-api";
-import { deriveTaskState, type TaskStatus } from "./state";
-import { hostTasks, setMirrorStatus } from "./remote";
-import type { TaskView } from "./index";
-import { viewOf } from "./move-targets";
-
-const FINISHED: Record<string, TaskStatus> = {
-  merged: "merged",
-  dropped: "dropped",
-  done: "done",
-};
+import type { Session } from "../../db";
+import { requireHostLink, type HostLink } from "../../hosts/remote-api";
+import { deriveTaskState } from "../state";
+import type { TaskView } from "../index";
+import { viewOf } from "../move-targets";
+import * as client from "./client";
 
 function offlineView(
   session: Session,
@@ -57,13 +51,13 @@ async function viewsOn(hostId: string, rows: Session[]): Promise<TaskView[]> {
     return rows.map((s) => offlineView(s, "", (err as Error).message));
   }
   try {
-    const { tasks, moved = [] } = await hostTasks(link);
+    const { tasks, moved = [] } = await client.list(link);
     const live = new Map(tasks.map((t) => [t.id, t]));
     const gone = new Set(moved.map((m) => m.id));
     return rows.flatMap((s): TaskView[] => {
       const t = live.get(s.id);
       if (!t) {
-        if (gone.has(s.id)) return (setMirrorStatus(s.id, "moved"), []);
+        if (gone.has(s.id)) return [];
         return [
           offlineView(
             s,
@@ -72,7 +66,6 @@ async function viewsOn(hostId: string, rows: Session[]): Promise<TaskView[]> {
           ),
         ];
       }
-      if (FINISHED[t.state]) setMirrorStatus(s.id, FINISHED[t.state]);
       return [
         {
           ...t,
@@ -92,7 +85,7 @@ async function viewsOn(hostId: string, rows: Session[]): Promise<TaskView[]> {
   }
 }
 
-export async function remoteTaskViews(mirrors: Session[]): Promise<TaskView[]> {
+export async function mirrorViews(mirrors: Session[]): Promise<TaskView[]> {
   const byHost = new Map<string, Session[]>();
   for (const s of mirrors)
     byHost.set(s.host_id, [...(byHost.get(s.host_id) ?? []), s]);

package/lib/tasks/finish.ts

@@ -1,6 +1,7 @@
 import { db, type Session } from "../db";
 import { endPauseOnFinish } from "./pause-hold";
-import { isMirror, remoteTaskAction } from "./remote";
+import { dropThere, mergeThere } from "./contract/actions";
+import { isMirror } from "./contract/start";
 import { deleteWorktree } from "../worktrees";
 import { settleWorktree, type MergedAs } from "../done/worktree";
 import {
@@ -37,6 +38,7 @@ import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
 import { snapshotWorktree } from "../resurrect/snapshot";
 import { keepSessionFiles } from "../session-artifacts/collect";
+import { setPr, setTask } from "../db/session-parts";
 
 // Never deleted, whatever a setting says.
 export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
@@ -141,7 +143,7 @@ export async function signOffTask(
   // Its own machine checks the gates and merges.
   // That machine's settings chose the method; null if it didn't say.
   if (isMirror(session))
-    return remoteTaskAction(session, "merge", opts.head, session.base_branch);
+    return mergeThere(session, opts.head, session.base_branch);
   const repo = projectPathFor(session);
   if (!repo) throw new Error("Task has no project");
   const refusal = signOffRefusal(id);
@@ -178,9 +180,10 @@ export async function signOffTask(
       method: policy.method,
       head: opts.head,
     });
-    db.prepare(
-      `UPDATE sessions SET task_status = 'merged', pr_status = 'merged' WHERE id = ?`
-    ).run(id);
+    db.transaction(() => {
+      setTask(db, id, { task_status: "merged" });
+      setPr(db, id, { pr_status: "merged" });
+    })();
     endPauseOnFinish(id);
     db.prepare(
       `UPDATE stack_items SET status = 'merged', error = NULL WHERE session_id = ?`
@@ -225,7 +228,7 @@ export async function dropTask(id: string): Promise<void> {
   if (session.task_status !== "running")
     throw new Error(`Task is already ${session.task_status}`);
   if (isMirror(session)) {
-    await remoteTaskAction(session, "drop");
+    await dropThere(session);
     return;
   }
   const repo = projectPathFor(session);
@@ -247,9 +250,7 @@ export async function dropTask(id: string): Promise<void> {
   if (pr?.state === "OPEN") {
     await run("gh", ["pr", "close", String(pr.number)], repo).catch(() => {});
   }
-  db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
-    id
-  );
+  setTask(db, id, { task_status: "dropped" });
   endPauseOnFinish(id);
   db.prepare(
     `UPDATE stack_items SET status = 'dropped' WHERE session_id = ?`

package/lib/tasks/held-replies.ts

@@ -8,7 +8,8 @@
 
 import { db, type Session } from "../db";
 import { sendMessage } from "../bus";
-import { hostApi, type HostLink } from "../hosts/remote-api";
+import type { HostLink } from "../hosts/remote-api";
+import * as client from "./contract/client";
 
 const PULL_EVERY_MS = 5000;
 const MISSING_FOR_MS = 10 * 60 * 1000;
@@ -27,13 +28,13 @@ interface Pulled {
   body: string;
 }
 
-// Held means an orchestrator started it, as isHeldRemote reads it.
+// Held means an orchestrator started it, as isHeldRemote reads it (contract/held-calls.ts).
 const HELD_BY = `started_by IN (SELECT id FROM sessions WHERE role = 'orchestrator')`;
 
 const heldMirror = (hostId: string, id: string) =>
   db
     .prepare(
-      `SELECT * FROM sessions WHERE id = ? AND host_id = ?
+      `SELECT * FROM session_rows WHERE id = ? AND host_id = ?
          AND ${HELD_BY} AND task_status IN ('running', 'moving')`
     )
     .get(id, hostId) as Session | undefined;
@@ -41,7 +42,7 @@ const heldMirror = (hostId: string, id: string) =>
 export function hasHeldMirrors(hostId: string): boolean {
   return !!db
     .prepare(
-      `SELECT 1 FROM sessions WHERE host_id = ? AND ${HELD_BY}
+      `SELECT 1 FROM session_rows WHERE host_id = ? AND ${HELD_BY}
          AND task_prompt IS NOT NULL AND task_status IN ('running', 'moving')`
     )
     .get(hostId);
@@ -58,11 +59,7 @@ export async function pullHeldReplies(link: HostLink): Promise<number> {
   try {
     let messages: Pulled[];
     try {
-      const res = await hostApi<{ messages?: unknown }>(
-        link,
-        "/api/tasks/held-replies",
-        { timeout: 8000 }
-      );
+      const res = await client.replies(link);
       messages = (Array.isArray(res.messages) ? res.messages : []).filter(
         (m): m is Pulled =>
           !!m &&
@@ -98,10 +95,7 @@ export async function pullHeldReplies(link: HostLink): Promise<number> {
       }
     }
     if (handled.length)
-      await hostApi(link, "/api/tasks/held-replies", {
-        body: { ids: handled },
-        timeout: 8000,
-      }).catch(() => undefined);
+      await client.ackReplies(link, handled).catch(() => undefined);
     return delivered;
   } finally {
     busy.delete(hostId);

package/lib/tasks/held.ts

@@ -8,7 +8,9 @@
 import { orchestratorOf } from "./starter";
 import os from "os";
 import { db, type Session } from "../db";
+import { isRemoteHost } from "../hosts";
 import type { OrchestratedBundle } from "./move-bundle";
+import { setPlacement, setTask } from "../db/session-parts";
 
 export function holderRefusal(
   session: Pick<Session, "held_by_device" | "held_from">,
@@ -25,7 +27,7 @@ export function heldRefusal(
   device: string | null | undefined
 ): string | null {
   const session = db
-    .prepare(`SELECT held_by_device, held_from FROM sessions WHERE id = ?`)
+    .prepare(`SELECT held_by_device, held_from FROM session_rows WHERE id = ?`)
     .get(id) as Pick<Session, "held_by_device" | "held_from"> | undefined;
   return session ? holderRefusal(session, device) : null;
 }
@@ -40,17 +42,15 @@ export function holdFor(
     since?: string | null;
   }
 ): void {
-  db.prepare(
-    `UPDATE sessions SET held_by_device = ?, held_from = ?, held_for = ?, held_for_name = ?,
-       task_since = COALESCE(?, task_since) WHERE id = ?`
-  ).run(
-    holder,
-    held.heldFrom,
-    held.orchestrator?.id ?? null,
-    held.orchestrator?.name ?? null,
-    held.since ?? null,
-    id
-  );
+  db.transaction(() => {
+    setPlacement(db, id, {
+      held_by_device: holder,
+      held_from: held.heldFrom,
+      held_for: held.orchestrator?.id ?? null,
+      held_for_name: held.orchestrator?.name ?? null,
+    });
+    setTask(db, id, { task_since: held.since ?? undefined });
+  })();
 }
 
 /**
@@ -80,10 +80,7 @@ const UNRECORDED_STARTER = "unrecorded";
 
 /** Records the paired device that started a task here, the only one that may later hold it. */
 export function recordStarter(id: string, device: string): void {
-  db.prepare(`UPDATE sessions SET started_by_device = ? WHERE id = ?`).run(
-    device,
-    id
-  );
+  setPlacement(db, id, { started_by_device: device });
 }
 
 type Holdable = Pick<
@@ -123,7 +120,7 @@ export function holdExisting(
   const s = db
     .prepare(
       `SELECT held_by_device, started_by, started_by_device, task_status, host_id, task_prompt
-       FROM sessions WHERE id = ?`
+       FROM session_rows WHERE id = ?`
     )
     .get(id) as Holdable | undefined;
   if (!s?.task_prompt || s.task_status !== "running") return false;
@@ -133,3 +130,25 @@ export function holdExisting(
   holdFor(id, device, held);
   return true;
 }
+
+/**
+ * A plan another machine placed here is read and approved by that machine
+ * only: it decides where the task is built. Null for any other task.
+ */
+export function planWaitRefusal(
+  id: string,
+  device: string | null | undefined
+): string | null {
+  const s = db
+    .prepare(
+      `SELECT plan_waits_for_caller, started_by_device, host_id FROM session_rows WHERE id = ?`
+    )
+    .get(id) as
+    | Pick<Session, "plan_waits_for_caller" | "started_by_device" | "host_id">
+    | undefined;
+  if (!s?.plan_waits_for_caller) return null;
+  // The placing machine's own mirror of the plan: its people decide it.
+  if (isRemoteHost(s.host_id)) return null;
+  if (device && device === s.started_by_device) return null;
+  return "The machine that placed this plan decides it; approve it from there";
+}

package/lib/tasks/hold-checks.ts

@@ -0,0 +1,134 @@
+/**
+ * The holds that read the database or this machine, each returning `Hold`s
+ * (holds.ts) so every caller that asks "may this start now" gets the same
+ * answer and the same words: the orchestrator's Pause and the usage window,
+ * `after`, and this machine's load for a start here.
+ */
+
+import type { Session } from "../db";
+import { getProject } from "../projects";
+import { isRemoteHost } from "../hosts";
+import { isPaused } from "../orchestrator/pause";
+import { brakesEnabled } from "../orchestrator/brakes";
+import { readUsage, windowRefusal } from "../orchestrator/usage";
+import { localView, machineCapabilities } from "../load/machines";
+import { DEFAULT_PRIORITY, type Priority } from "./schedule-types";
+import { machineHolds, holdReason, type Hold } from "./holds";
+import { heavyNeeds, meetsNeeds, needsOf, type Need } from "./placement";
+import { expandHome } from "./session";
+import { afterLabel, hasFinished } from "./queue-rows";
+import type { QueueRow } from "./queue-types";
+import type { PauseBy } from "./schedule-types";
+
+// Why an automatic start has to wait: the orchestrator's Pause, then the
+// usage window. A start now by a person isn't held, and a plan-only start
+// is held by Pause alone.
+export function autoHolds(
+  workspaceId: string | null,
+  planOnly = false
+): Hold[] {
+  const out: Hold[] = [];
+  if (workspaceId && isPaused(workspaceId))
+    out.push({
+      code: "orch_paused",
+      text: "Waiting: the orchestrator is paused",
+    });
+  if (planOnly) return out;
+  const window = brakesEnabled() ? windowRefusal(readUsage()) : null;
+  if (window) out.push({ code: "window", text: `Waiting: ${window}` });
+  return out;
+}
+
+export const autoHold = (
+  workspaceId: string | null,
+  planOnly = false
+): Hold | null => autoHolds(workspaceId, planOnly)[0] ?? null;
+
+// `after X`: the task it waits on hasn't finished.
+export function afterHold(r: QueueRow): Hold | null {
+  if (!r.after_task || hasFinished(r.after_task)) return null;
+  return {
+    code: "after",
+    text: `After ${afterLabel({ ...r, after_any: null }) ?? "its task"}`,
+  };
+}
+
+// What this machine would say to a start of a task with these needs here
+// and now: empty means it may start.
+export function localHolds(
+  ask: { needs: Need[]; priority?: Priority },
+  now = Date.now()
+): Hold[] {
+  return machineHolds(
+    {
+      heavy: heavyNeeds(ask.needs),
+      needsUnmet: !meetsNeeds(ask.needs, machineCapabilities()),
+      remote: false,
+      priority: ask.priority ?? DEFAULT_PRIORITY,
+    },
+    localView(now),
+    now
+  );
+}
+
+export const requestNeeds = (
+  projectId: string,
+  workingDirectory: string,
+  prompt: string,
+  setting: Need[] | null
+): Need[] =>
+  setting ??
+  needsOf({
+    projectId,
+    projectPath: expandHome(workingDirectory),
+    prompt,
+  }).needs;
+
+// Whether the task needs something this machine lacks (a Mac).
+export function needsUnmetHere(
+  projectId: string,
+  prompt: string,
+  setting: Need[] | null
+): boolean {
+  const project = getProject(projectId);
+  if (!project || isRemoteHost(project.host_id)) return false;
+  return !meetsNeeds(
+    requestNeeds(projectId, project.working_directory, prompt, setting),
+    machineCapabilities()
+  );
+}
+
+// Whether this machine's load rules out starting a task for this project now.
+export function loadHeldStart(
+  projectId: string,
+  prompt: string,
+  setting: Need[] | null
+): boolean {
+  const project = getProject(projectId);
+  if (!project || isRemoteHost(project.host_id)) return false;
+  const head = localHolds({
+    needs: requestNeeds(projectId, project.working_directory, prompt, setting),
+  })[0];
+  return head?.code === "load_red" || head?.code === "heavy";
+}
+
+// Why this machine's load rules out starting an agent now, or null. Only a
+// red (or still settling) machine holds a resume; amber doesn't.
+export function loadHoldFor(s: Session): string | null {
+  const project = s.project_id ? getProject(s.project_id) : null;
+  if (!project || isRemoteHost(s.host_id ?? project.host_id)) return null;
+  const hold = localHolds({ needs: [] })[0];
+  return hold?.code === "load_red" ? holdReason(hold) : null;
+}
+
+// Why a resume this actor asked for must wait: this machine's load, and for
+// the orchestrator also what holds its own starts (it is paused, or the
+// usage window). A person's own resume skips the second.
+export function resumeHoldFor(s: Session, actor: PauseBy): string | null {
+  const load = loadHoldFor(s);
+  if (load) return load;
+  if (actor !== "orchestrator") return null;
+  const ws = s.project_id ? getProject(s.project_id)?.workspace_id : null;
+  const hold = autoHold(ws ?? null);
+  return hold ? holdReason(hold) : null;
+}