@saadnvd1/agent-os 0.3.637 → 0.3.644

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

@@ -9,40 +9,44 @@
  * Moving the task reuses the ordinary move (move-flow.ts).
  */
 
-import fs from "fs";
+import fs from "fs/promises";
 import path from "path";
-import { db, type Session } from "../db";
-import { isRemoteHost } from "../hosts";
-import { peerSource } from "../hosts/peer-load";
-import { hostApi, hostLink, requireHostLink } from "../hosts/remote-api";
-import { LOCAL, machineCapabilities } from "../load/machines";
-import { noApprovalsOn, recordAutoApproval } from "../approvals/no-approvals";
-import { implementArrived, planNoteFor } from "../models/plan-step";
-import { sessionWorkspace } from "../models/resolve";
-import { queueEvent } from "../orchestrator/events";
-import { brakesOn } from "../orchestrator/brakes";
-import { isPaused } from "../orchestrator/pause";
-import { getProject } from "../projects";
-import { planFor, splitOf } from "../plans/features";
-import { forgetHostTasks, hostTasks } from "./remote";
-import { moveTask } from "./move-flow";
-import { meetsNeeds, needsOf } from "./placement";
-import { remotePlanPath } from "./remote-plan-path";
-import { DEFAULT_PRIORITY, isPriority } from "./schedule-types";
-import { localHolds } from "./hold-checks";
-import { expandHome } from "./session";
-import { orchestratorOf } from "./starter";
+import { db, type Session } from "../../db";
+import { isRemoteHost } from "../../hosts";
+import { peerSource } from "../../hosts/peer-load";
+import { hostLink, requireHostLink } from "../../hosts/remote-api";
+import { LOCAL, machineCapabilities } from "../../load/machines";
+import {
+  noApprovalsOn,
+  recordAutoApproval,
+} from "../../approvals/no-approvals";
+import { implementArrived, planNoteFor } from "../../models/plan-step";
+import { sessionWorkspace } from "../../models/resolve";
+import { queueEvent } from "../../orchestrator/events";
+import { brakesOn } from "../../orchestrator/brakes";
+import { isPaused } from "../../orchestrator/pause";
+import { getProject } from "../../projects";
+import { planFor, splitOf } from "../../plans/features";
+import { moveTask } from "../move-flow";
+import * as client from "./client";
+import { meetsNeeds, needsOf } from "../placement";
+import { remotePlanPath } from "./plan-path";
+import { DEFAULT_PRIORITY, isPriority } from "../schedule-types";
+import { localHolds } from "../hold-checks";
+import { expandHome } from "../session";
+import { orchestratorOf } from "../starter";
+import { setPlan } from "../../db/session-parts";
 
 export { remotePlanPath };
 
 const getSession = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
 
-function readCopy(id: string): string | null {
+async function readCopy(id: string): Promise<string | null> {
   try {
-    return fs.readFileSync(remotePlanPath(id), "utf8");
+    return await fs.readFile(remotePlanPath(id), "utf8");
   } catch {
     return null;
   }
@@ -81,29 +85,27 @@ export function implementTarget(
   return meetsNeeds(needs, machineCapabilities()) ? "home" : "there";
 }
 
-// One look at a mirror that is planning: if its plan is written there, copy
-// it, say so, and carry on for a plan-first task.
-async function planWritten(s: Session): Promise<void> {
+/**
+ * A mirror that is planning, its machine's listing of it in hand: if its plan
+ * is written there, copy it, say so, and carry on for a plan-first task.
+ */
+export async function planWritten(
+  s: Session,
+  view: { planReady?: boolean } | undefined
+): 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);
-  if (!view?.planReady) return;
-  const { text } = await hostApi<{ text: string | null }>(
-    link,
-    `/api/tasks/${encodeURIComponent(s.id)}/plan`,
-    { timeout: 30000 }
+  if (!link || !view?.planReady) return;
+  const text = await client.plan(link, s.id);
+  const claimed = setPlan(
+    db,
+    s.id,
+    { plan_phase: "awaiting" },
+    { plan_phase: "planning" }
   );
-  const claimed = db
-    .prepare(
-      `UPDATE sessions SET plan_phase = 'awaiting' WHERE id = ? AND plan_phase = 'planning'`
-    )
-    .run(s.id).changes;
   if (!claimed) return;
   if (text !== null) {
-    fs.mkdirSync(path.dirname(remotePlanPath(s.id)), { recursive: true });
-    fs.writeFileSync(remotePlanPath(s.id), text);
+    await fs.mkdir(path.dirname(remotePlanPath(s.id)), { recursive: true });
+    await fs.writeFile(remotePlanPath(s.id), text);
   }
   const fresh = getSession(s.id)!;
   const split = checkedSplit(fresh, text);
@@ -121,7 +123,7 @@ async function planWritten(s: Session): Promise<void> {
         ? "moving here to implement once this machine is free"
         : "waiting for approval, not implementing (approve_plan to go ahead, drop to reject)";
   const note = planNoteFor(fresh, remotePlanPath(s.id), next);
-  db.prepare(`UPDATE sessions SET plan_note = ? WHERE id = ?`).run(note, s.id);
+  setPlan(db, s.id, { plan_note: note });
   const workspaceId = sessionWorkspace(fresh);
   if (orchestratorOf(fresh.started_by) && workspaceId) {
     queueEvent(workspaceId, `plan-done:${s.id}`, s.id, note);
@@ -136,7 +138,7 @@ async function planWritten(s: Session): Promise<void> {
   if (!goOn) {
     try {
       const planned = text ? planFor(fresh, text) : null;
-      (await import("../notify/push/events")).pushPlanAwaiting(
+      (await import("../../notify/push/events")).pushPlanAwaiting(
         s.id,
         s.name,
         planned?.pieces.length ?? 1
@@ -146,7 +148,7 @@ async function planWritten(s: Session): Promise<void> {
     }
     return;
   }
-  await continueRemotePlan(fresh);
+  await continuePlanThere(fresh);
   if (auto)
     recordAutoApproval({
       source: "plan",
@@ -161,28 +163,29 @@ async function planWritten(s: Session): Promise<void> {
  * Carries a written plan on: approves it on the machine that planned it, or
  * hands it to the move home. Returns what it will implement on.
  */
-export async function continueRemotePlan(
+export async function continuePlanThere(
   s: Session,
   message?: string
 ): Promise<string> {
   const link = requireHostLink(s.host_id!);
-  const split = checkedSplit(s, readCopy(s.id));
+  const split = checkedSplit(s, await readCopy(s.id));
   if (implementTarget(s, split) === "there") {
-    const out = await hostApi<{ model?: string }>(
-      link,
-      `/api/tasks/${encodeURIComponent(s.id)}/approve-plan`,
-      { body: message ? { message } : {}, timeout: 60000 }
+    const out = await client.approvePlan(link, s.id, message);
+    setPlan(
+      db,
+      s.id,
+      { plan_phase: "implementing" },
+      { plan_phase: "awaiting" }
     );
-    db.prepare(
-      `UPDATE sessions SET plan_phase = 'implementing' WHERE id = ? AND plan_phase = 'awaiting'`
-    ).run(s.id);
-    forgetHostTasks(link.hostId);
+    client.forget(link.hostId);
     return out.model ?? link.hostName;
   }
-  db.prepare(
-    `UPDATE sessions SET plan_phase = 'handoff', plan_handoff_message = ?
-     WHERE id = ? AND plan_phase = 'awaiting'`
-  ).run(message ?? null, s.id);
+  setPlan(
+    db,
+    s.id,
+    { plan_phase: "handoff", plan_handoff_message: message ?? null },
+    { plan_phase: "awaiting" }
+  );
   const workspaceId = sessionWorkspace(s);
   if (orchestratorOf(s.started_by) && workspaceId)
     queueEvent(
@@ -197,18 +200,19 @@ export async function continueRemotePlan(
   return "this machine, once it is free";
 }
 
-const handingOff = new Set<string>();
+export const handingOff = new Set<string>();
 
-async function finishArrival(id: string, message?: string): Promise<boolean> {
+export async function finishArrival(
+  id: string,
+  message?: string
+): Promise<boolean> {
   await implementArrived(id, message || undefined);
-  db.prepare(
-    `UPDATE sessions SET plan_handoff_message = NULL WHERE id = ?`
-  ).run(id);
+  setPlan(db, id, { plan_handoff_message: null });
   return true;
 }
 
 // Fired, not awaited: a move takes minutes and the queue tick must not wait.
-function fire(id: string, run: () => Promise<unknown>) {
+export function fire(id: string, run: () => Promise<unknown>) {
   if (handingOff.has(id)) return;
   void run().catch((e) => console.error(`Moving ${id} here failed:`, e));
 }
@@ -253,10 +257,11 @@ export async function handoffHome(
     const edits = s.plan_edits ?? null;
     const arrived = await moveTask(id, LOCAL);
     // The arrived row keeps the pending hand-off until implementing has
-    // started, so a restart in between is picked up by syncRemotePlans.
-    db.prepare(
-      `UPDATE sessions SET plan_edits = COALESCE(?, plan_edits), plan_handoff_message = ? WHERE id = ?`
-    ).run(edits, message ?? "", arrived.id);
+    // started, so a restart in between is picked up by syncMirrors.
+    setPlan(db, arrived.id, {
+      plan_edits: edits ?? undefined,
+      plan_handoff_message: message ?? "",
+    });
     handingOff.add(arrived.id);
     try {
       return await finishArrival(arrived.id, message);
@@ -267,42 +272,3 @@ export async function handoffHome(
     handingOff.delete(id);
   }
 }
-
-/** Every mirror whose plan is being written, or approved and coming here. */
-export async function syncRemotePlans(): Promise<void> {
-  const rows = db
-    .prepare(
-      `SELECT * FROM sessions
-       WHERE plan_waits_for_caller = 1 AND plan_phase IN ('planning', 'handoff')
-         AND task_status = 'running' AND archived_at IS NULL`
-    )
-    .all() as Session[];
-  for (const s of rows) {
-    if (!isRemoteHost(s.host_id)) continue;
-    try {
-      if (s.plan_phase === "planning") await planWritten(s);
-      else fire(s.id, () => handoffHome(s.id));
-    } catch (e) {
-      console.error(`Plan on ${s.host_id} for ${s.id} failed:`, e);
-    }
-  }
-  // A task that arrived but never began implementing (a restart between).
-  const arrived = db
-    .prepare(
-      `SELECT id, plan_handoff_message FROM sessions
-       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/routes.ts

@@ -0,0 +1,26 @@
+/** The task routes a linked machine's AgentOS answers, and how long to wait for each. */
+
+export const taskPath = (id: string, leaf: string) =>
+  `/api/tasks/${encodeURIComponent(id)}/${leaf}`;
+
+export const LIST = "/api/tasks";
+export const IMPORT = "/api/tasks/import";
+export const HELD_REPLIES = "/api/tasks/held-replies";
+export const arrivedPath = (from: string) =>
+  `/api/tasks/arrived?from=${encodeURIComponent(from)}`;
+
+export const TIMEOUT = {
+  list: 8000,
+  start: 180000,
+  plan: 30000,
+  approvePlan: 60000,
+  message: 20000,
+  hold: 20000,
+  chat: 10000,
+  stop: 30000,
+  done: 120000,
+  merge: 300000,
+  replies: 8000,
+  exportOut: 300000,
+  importBundle: 600000,
+} as const;

package/lib/tasks/contract/start.ts

@@ -0,0 +1,122 @@
+/**
+ * Tasks that run on another machine's AgentOS. That machine schedules them;
+ * this one keeps a mirror row (same id, the host's id) so the sidebar lists
+ * them and the terminal attaches through that machine's AgentOS.
+ */
+
+import { db, type Project, type Session } from "../../db";
+import { isRemoteHost } from "../../hosts";
+import { requireHostLink } from "../../hosts/remote-api";
+import { orchestratedStart } from "../held";
+import { projectRef } from "../project-ref";
+import { orchestratorOf } from "../starter";
+import type { TaskStatus } from "../state";
+import * as client from "./client";
+import { setPlan, setTask, startTaskClock } from "../../db/session-parts";
+
+export function isMirror(session: Session): boolean {
+  return isRemoteHost(session.host_id);
+}
+
+export function mirrorTask(
+  hostId: string,
+  projectId: string | null,
+  remote: Session,
+  startedBy?: string | null
+): void {
+  db.transaction(() => {
+    const inserted = db
+      .prepare(
+        `INSERT INTO sessions (id, name, tmux_name, working_directory, model, group_path,
+           agent_type, auto_approve, project_id, host_id, worktree_path, branch_name,
+           base_branch, name_source, view)
+         VALUES (?, ?, ?, ?, ?, 'sessions', 'claude', 1, ?, ?, ?, ?, ?, 'user', ?)
+         ON CONFLICT(id) DO NOTHING`
+      )
+      .run(
+        remote.id,
+        remote.name,
+        remote.tmux_name,
+        remote.working_directory,
+        remote.model,
+        projectId,
+        hostId,
+        remote.worktree_path,
+        remote.branch_name,
+        remote.base_branch,
+        // As that machine runs it: one that predates chat tasks says terminal.
+        remote.view === "chat" ? "chat" : "terminal"
+      );
+    if (inserted.changes)
+      setTask(db, remote.id, {
+        task_prompt: remote.task_prompt,
+        task_status: "running",
+      });
+    // What carryTaskState gives a moved task's mirror: the orchestrator that
+    // holds it, and when it began (so its PR is judged from then).
+    if (startedBy) {
+      db.prepare(
+        `UPDATE sessions SET started_by = COALESCE(started_by, ?) WHERE id = ?`
+      ).run(startedBy, remote.id);
+      startTaskClock(db, remote.id);
+    }
+  })();
+}
+
+export async function startRemoteTask(
+  hostId: string,
+  project: Project,
+  opts: {
+    id: string;
+    prompt: string;
+    name?: string;
+    model?: string;
+    baseBranch?: string;
+    view?: "chat" | "terminal";
+    // The orchestrator that started it: that machine holds the task for it.
+    startedBy?: string | null;
+    // It plans first: there it plans, stops, and waits for this machine.
+    plan?: { only: boolean; reason: string | null };
+  }
+): Promise<Session> {
+  const link = requireHostLink(hostId);
+  const { startedBy: by, plan, ...rest } = opts;
+  const startedBy = orchestratorOf(by);
+  if (startedBy)
+    await client.requireCapability(
+      link,
+      "held-start",
+      "an orchestrator's task",
+      "hold"
+    );
+  if (plan)
+    await client.requireCapability(link, "remote-plan", "a plan step", "plan");
+  const { session } = await client.start(link, {
+    project: await projectRef(project),
+    ...rest,
+    ...(plan && {
+      plan: true,
+      plan_only: true,
+      plan_waits: true,
+      plan_reason: plan.reason ?? undefined,
+    }),
+    orchestrated: startedBy ? orchestratedStart(startedBy) : undefined,
+  });
+  mirrorTask(hostId, project.id, session, startedBy);
+  if (plan)
+    setPlan(db, session.id, {
+      plan_phase: "planning",
+      plan_only: plan.only ? 1 : null,
+      plan_decided: 1,
+      plan_reason: plan.reason,
+      plan_waits_for_caller: 1,
+    });
+  client.forget(hostId);
+  return db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(session.id) as Session;
+}
+
+export function setMirrorStatus(id: string, status: TaskStatus): void {
+  setTask(db, id, { task_status: status }, { task_status: "running" });
+}

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]);