@saadnvd1/agent-os 0.3.637 → 0.3.644

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 {
@@ -15,7 +16,8 @@ import { resolveMergedTaskAsks } from "../orchestrator/ask-settle";
 import { endSessionAgent } from "../sessions/end";
 import { run } from "./gh";
 import { pushMerged } from "../notify/push/events";
-import { gitFetch, gitPush } from "../git-exec";
+import { gitFetch } from "../git-exec";
+import { deleteTaskBranch } from "./remote-branch";
 import {
   mergePolicy,
   type MergeMethod,
@@ -37,9 +39,7 @@ import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
 import { snapshotWorktree } from "../resurrect/snapshot";
 import { keepSessionFiles } from "../session-artifacts/collect";
-
-// Never deleted, whatever a setting says.
-export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
+import { setPr, setTask } from "../db/session-parts";
 
 export const sessionMergePolicy = (session: Session): MergePolicy =>
   mergePolicy(session.project_id ? getProject(session.project_id) : null);
@@ -50,7 +50,14 @@ export const sessionMergePolicy = (session: Session): MergePolicy =>
 async function cleanup(
   session: Session,
   repo: string,
-  opts: { keepRemoteBranch?: boolean; merged?: MergedAs } = {}
+  opts: {
+    keepRemoteBranch?: boolean;
+    merged?: MergedAs;
+    // The head the PR merged or closed at.
+    prHead?: string | null;
+    // A drop of a task that never had a PR.
+    noPr?: boolean;
+  } = {}
 ): Promise<void> {
   const keepRemoteBranch = opts.keepRemoteBranch ?? false;
   await endSessionAgent(session);
@@ -66,14 +73,14 @@ async function cleanup(
   }
   // A stacked child's PR targets this branch: deleting it on origin would
   // make GitHub close that PR, and a closed PR can't be retargeted.
-  if (
-    session.branch_name &&
-    !keepRemoteBranch &&
-    !PROTECTED_BRANCHES.has(session.branch_name)
-  ) {
-    await gitPush(repo, ["origin", "--delete", session.branch_name]).catch(
-      () => {}
-    );
+  if (session.branch_name && !keepRemoteBranch) {
+    await deleteTaskBranch({
+      repo,
+      branch: session.branch_name,
+      prHead: opts.prHead,
+      noPr: opts.noPr,
+      keep: [session.base_branch],
+    });
   }
   await gitFetch(repo, ["--prune", "--quiet"]).catch(() => {});
   forgetPR(session.id);
@@ -110,6 +117,7 @@ async function finishMerge(
   await cleanup(session, repo, {
     keepRemoteBranch: stuck || !policy.delete_remote_branch,
     merged: { prHead },
+    prHead,
   });
   // After cleanup's fetch, so the base branch holds the merged files.
   inBackground(`re-publish docs after task ${session.id}`, () =>
@@ -141,7 +149,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 +186,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 +234,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,14 +256,12 @@ 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 = ?`
   ).run(id);
   syncTaskCardInBackground(session, "dropped", pr);
   await snapshot;
-  await cleanup(session, repo);
+  await cleanup(session, repo, { prHead: pr?.head, noPr: !pr });
 }

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

@@ -10,6 +10,7 @@ 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">,
@@ -26,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;
 }
@@ -41,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 });
+  })();
 }
 
 /**
@@ -81,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<
@@ -124,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;
@@ -145,7 +141,7 @@ export function planWaitRefusal(
 ): string | null {
   const s = db
     .prepare(
-      `SELECT plan_waits_for_caller, started_by_device, host_id FROM sessions WHERE id = ?`
+      `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">

package/lib/tasks/import.ts

@@ -38,6 +38,7 @@ import {
   validateBundle,
   type TaskBundle,
 } from "./move-bundle";
+import { setPlan, setTask } from "../db/session-parts";
 
 // Imports in flight in this process, by move id.
 const g = globalThis as unknown as { __agentosImporting?: Set<string> };
@@ -47,7 +48,7 @@ const importing = (g.__agentosImporting ??= new Set());
 export const arrived = (moveId: string) =>
   db
     .prepare(
-      `SELECT * FROM sessions WHERE moved_from = ? AND host_id = 'local'
+      `SELECT * FROM session_rows WHERE moved_from = ? AND host_id = 'local'
          AND task_status IN ('running', 'moving', 'moved', 'merged', 'done')`
     )
     .get(moveId) as Session | undefined;
@@ -56,7 +57,7 @@ export const arrived = (moveId: string) =>
 function refuseBusyBranch(projectId: string, branch: string): void {
   const busy = db
     .prepare(
-      `SELECT id FROM sessions WHERE project_id = ? AND branch_name = ?
+      `SELECT id FROM session_rows WHERE project_id = ? AND branch_name = ?
          AND task_status IN ('running', 'moving') AND host_id = 'local'`
     )
     .get(projectId, branch);
@@ -166,26 +167,29 @@ async function arrive(
       .run(worktreePath, bundle.branch, baseBranch, null, id);
     // A chat's worker reads its brief from the row; a terminal's is passed.
     db.prepare(
-      `UPDATE sessions SET task_prompt = ?, task_brief = ?, task_status = 'running', name_source = 'user',
-         claude_session_id = ?, moved_from = ? WHERE id = ?`
-    ).run(bundle.prompt, brief, claude?.sessionId ?? null, bundle.moveId, id);
+      `UPDATE sessions SET name_source = 'user', claude_session_id = ? WHERE id = ?`
+    ).run(claude?.sessionId ?? null, id);
+    setTask(db, id, {
+      task_prompt: bundle.prompt,
+      task_brief: brief,
+      task_status: "running",
+      moved_from: bundle.moveId,
+    });
     if (bundle.chat) unpackChat(id, bundle.chat, paths);
-    if (bundle.planWait)
-      db.prepare(
-        `UPDATE sessions SET plan_phase = 'awaiting' WHERE id = ?`
-      ).run(id);
+    if (bundle.planWait) setPlan(db, id, { plan_phase: "awaiting" });
     if (orch) {
-      db.prepare(
-        `UPDATE sessions SET plan_phase = ?, task_since = ? WHERE id = ?`
-      ).run(orch.planPhase, orch.since, id);
+      setPlan(db, id, { plan_phase: orch.planPhase });
+      setTask(db, id, { task_since: orch.since });
       // Held for the orchestrator's device. The orchestrator's own state
       // (started_by, its gates) never comes from the bundle: it stays on its
       // machine, and a task coming back takes it from the mirror's record.
       if (holder) {
         holdFor(id, holder, orch);
-        db.prepare(
-          `UPDATE sessions SET model_provider = ?, model_overrides = ? WHERE id = ?`
-        ).run(orch.modelProvider, orch.modelOverrides, id);
+        db.prepare(`UPDATE sessions SET model_provider = ? WHERE id = ?`).run(
+          orch.modelProvider,
+          id
+        );
+        setTask(db, id, { model_overrides: orch.modelOverrides });
       }
     }
     carryTaskState(bundle.moveId, id);

package/lib/tasks/index.ts

@@ -59,12 +59,13 @@ import { finishTaskStart } from "./start";
 import { isRemoteHost } from "../hosts";
 import { DEFAULT_START_VIEW, type StartView } from "../sessions/launch";
 import { viewOf } from "./move-targets";
-import { isMirror, startRemoteTask } from "./remote";
-import { remoteTaskViews } from "./remote-views";
+import { isMirror, startRemoteTask } from "./contract/start";
+import { mirrorViews } from "./contract/views";
 import { chatStateNow } from "../chat/runner";
 import { saidSinceLastMessage } from "../chat/store";
 
 import { lastActiveOf } from "./last-active";
+import { setPlan, setTask } from "../db/session-parts";
 export * from "./state";
 export { codeReviewGate, codeReviewRefusal } from "./code-review";
 export { signOffTask, dropTask, signingOff, mergeSettled } from "./finish";
@@ -258,7 +259,7 @@ async function startTask(
     if (opts.planOnly && view !== "chat")
       throw new Error("A plan-only task needs a chat, not a terminal");
     // The plan step is this machine's to run and decide: it plans there,
-    // stops, and what follows is chosen here (remote-plan.ts).
+    // stops, and what follows is chosen here (contract/plan.ts).
     const planned =
       !!(opts.plan || opts.planOnly) &&
       taskRouting(
@@ -280,7 +281,7 @@ async function startTask(
         ? { only: !!opts.planOnly, reason: opts.planReason?.trim() || null }
         : undefined,
     });
-    // The mirror's started_by stays orchestrator-only: a held-remote task is
+    // The mirror's started_by stays orchestrator-only: a held task on a linked machine is
     // relayed, stopped and answered through it. A plain calling task is its
     // parent and started_via only.
     recordStart(session.id, {
@@ -366,30 +367,41 @@ async function startTask(
       .run(wt.worktreePath, wt.branchName, baseBranch, null, id);
     // Everything the launch needs is on the row, so a restart can resume it.
     db.prepare(
-      `UPDATE sessions SET task_prompt = ?, task_brief = ?, task_status = 'running', setup_status = 'running', name_source = ?, view = ?,
-         model_provider = ?, model_overrides = ?, plan_phase = ?, plan_only = ?,
-         plan_decided = ?, plan_reason = ?, plan_waits_for_caller = ? WHERE id = ?`
+      `UPDATE sessions SET setup_status = 'running', name_source = ?, view = ?, model_provider = ? WHERE id = ?`
     ).run(
-      prompt,
-      buildTaskBrief({
-        branch: wt.branchName,
-        baseBranch,
-        stack: opts.base?.stack,
-        test: declaredTest(wt.worktreePath),
-      }),
       naming.source,
       view,
       routing.first.provider.id === ANTHROPIC
         ? null
         : routing.first.provider.id,
-      routing.override ? JSON.stringify(routing.override) : null,
-      routing.plan ? "planning" : null,
-      routing.planOnly ? 1 : null,
-      routing.planOnly ? 1 : opts.plan === undefined ? null : opts.plan ? 1 : 0,
-      opts.planReason?.trim() || null,
-      routing.planOnly && opts.planWaits ? 1 : null,
       id
     );
+    setTask(db, id, {
+      task_prompt: prompt,
+      task_brief: buildTaskBrief({
+        branch: wt.branchName,
+        baseBranch,
+        stack: opts.base?.stack,
+        test: declaredTest(wt.worktreePath),
+      }),
+      task_status: "running",
+      model_overrides: routing.override
+        ? JSON.stringify(routing.override)
+        : null,
+    });
+    setPlan(db, id, {
+      plan_phase: routing.plan ? "planning" : null,
+      plan_only: routing.planOnly ? 1 : null,
+      plan_decided: routing.planOnly
+        ? 1
+        : opts.plan === undefined
+          ? null
+          : opts.plan
+            ? 1
+            : 0,
+      plan_reason: opts.planReason?.trim() || null,
+      plan_waits_for_caller: routing.planOnly && opts.planWaits ? 1 : null,
+    });
     recordStart(id, {
       startedBy: opts.startedBy ?? null,
       parentSessionId: opts.parentSessionId ?? null,
@@ -532,7 +544,7 @@ export async function taskView(session: Session): Promise<TaskView> {
 export function movedTasks(): { id: string; movedTo: string | null }[] {
   return db
     .prepare(
-      `SELECT id, moved_to AS movedTo FROM sessions
+      `SELECT id, moved_to AS movedTo FROM session_rows
          WHERE task_status = 'moved' AND host_id = 'local'
          ORDER BY updated_at DESC LIMIT 500`
     )
@@ -544,7 +556,7 @@ export async function listTasks(): Promise<TaskView[]> {
   const sessions = taskSessions(false);
   const [local, remote] = await Promise.all([
     Promise.all(sessions.filter((s) => !isMirror(s)).map(taskView)),
-    remoteTaskViews(sessions.filter(isMirror)),
+    mirrorViews(sessions.filter(isMirror)),
   ]);
   const costs = taskCosts(local.map((t) => t.id));
   for (const t of local) {

package/lib/tasks/launch-gate.ts

@@ -9,7 +9,7 @@ import { db } from "../db";
 export function launchPending(sessionId: string): boolean {
   const row = db
     .prepare(
-      `SELECT 1 FROM sessions WHERE id = ? AND task_status = 'running'
+      `SELECT 1 FROM session_rows WHERE id = ? AND task_status = 'running'
          AND setup_status IN ('running', 'held')`
     )
     .get(sessionId);

package/lib/tasks/move-carry.ts

@@ -10,6 +10,7 @@
 import type Database from "better-sqlite3";
 import { db } from "../db";
 import { orchestratorOf } from "./starter";
+import { fillMissing } from "../db/session-parts";
 
 // table, column, and how the id sits in it: the whole value, `task:<id>`, or
 // the tail of a `<condition>:<id>` key.
@@ -100,15 +101,22 @@ export function carryTaskState(
         .run(fromId.length, toId, `%:${fromId}`);
   }
   const from = handle
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows 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({
+  const carried = {
     ...orchestrationOf(from),
     task_since: (from.task_since as string | null) ?? from.created_at ?? null,
-    id: toId,
-  });
+  } as Record<string, string | number | null>;
+  handle
+    .prepare(
+      `UPDATE sessions SET started_by = COALESCE(started_by, @started_by),
+         model_provider = COALESCE(model_provider, @model_provider) WHERE id = @id`
+    )
+    .run({
+      started_by: carried.started_by,
+      model_provider: carried.model_provider,
+      id: toId,
+    });
+  fillMissing(handle, toId, carried);
 }

package/lib/tasks/move-flow.ts

@@ -16,19 +16,15 @@ import { holderRefusal } from "./held";
 import { isPaused } from "../orchestrator/pause";
 import { sessionWorkspace } from "../models/resolve";
 import { arrived as arrivedHere, importTask } from "./import";
-import {
-  forgetHostTasks,
-  requireCapability,
-  postIdempotent,
-  unknownOutcome,
-} from "./remote";
-import { arrivedThere, settleMovedOut, tell } from "./move-recover";
+import * as client from "./contract/client";
+import { arrivedThere, settleMovedOut } from "./move-recover";
 import {
   finishProgress,
   moveSteps,
   startProgress,
   stepProgress,
 } from "./move-progress";
+import { setTask } from "../db/session-parts";
 
 const LIVE = new Set(["running", "moving"]);
 
@@ -89,7 +85,7 @@ export async function moveTask(id: string, toHostId: string): Promise<Session> {
 }
 
 const requireChatMoves = (link: HostLink) =>
-  requireCapability(link, "chat-move", "chat tasks");
+  client.requireCapability(link, "chat-move", "chat tasks");
 
 const unconfirmed = (where: string, err: unknown) =>
   new Error(
@@ -101,7 +97,11 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
   const chat = session.view === "chat";
   if (chat) await requireChatMoves(link);
   if (isOrchestrated(session))
-    await requireCapability(link, "orchestrated-move", "orchestrator tasks");
+    await client.requireCapability(
+      link,
+      "orchestrated-move",
+      "orchestrator tasks"
+    );
   startProgress(
     session.id,
     link.hostName,
@@ -118,15 +118,10 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
   stepProgress(session.id, "arrive");
   let there: Session;
   try {
-    ({ session: there } = await postIdempotent<{ session: Session }>(
-      link,
-      "/api/tasks/import",
-      bundle,
-      600000
-    ));
+    ({ session: there } = await client.importBundle(link, bundle));
   } catch (err) {
     // It may be running there already: resuming here could run it twice.
-    if (unknownOutcome(err)) throw unconfirmed(link.hostName, err);
+    if (client.unknownOutcome(err)) throw unconfirmed(link.hostName, err);
     await resumeTask(session.id);
     throw err;
   }
@@ -134,45 +129,43 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
 }
 
 function mirrorRunning(id: string): void {
-  db.prepare(
-    `UPDATE sessions SET task_status = 'running', moved_to = NULL
-       WHERE id = ? AND task_status = 'moving'`
-  ).run(id);
+  setTask(
+    db,
+    id,
+    { task_status: "running", moved_to: null },
+    { task_status: "moving" }
+  );
 }
 
 async function moveIn(mirror: Session): Promise<Session> {
   const link = requireHostLink(mirror.host_id);
   if (mirror.view === "chat") await requireChatMoves(link);
   startProgress(mirror.id, "this machine", moveSteps("in", link.hostName));
-  const path = `/api/tasks/${encodeURIComponent(mirror.id)}`;
   // A retry after it arrived here but that machine didn't hear: tidy up.
   let here = arrivedHere(mirror.id);
   if (!here) {
     // Moving, so nothing reads the mirror as a task to judge, or sign off,
     // while it leaves (a refusal below puts it back).
-    db.prepare(
-      `UPDATE sessions SET task_status = 'moving', moved_to = 'this machine'
-         WHERE id = ? AND task_status = 'running'`
-    ).run(mirror.id);
+    setTask(
+      db,
+      mirror.id,
+      { task_status: "moving", moved_to: "this machine" },
+      { task_status: "running" }
+    );
     // That machine resumes the agent itself if its half fails there.
     stepProgress(mirror.id, "export");
     let bundle: TaskBundle;
     try {
-      ({ bundle } = await postIdempotent<{ bundle: TaskBundle }>(
-        link,
-        `${path}/export`,
-        { to: os.hostname() },
-        300000
-      ));
+      bundle = await client.exportOut(link, mirror.id, os.hostname());
     } catch (err) {
       mirrorRunning(mirror.id);
-      if (unknownOutcome(err)) throw unconfirmed(link.hostName, err);
+      if (client.unknownOutcome(err)) throw unconfirmed(link.hostName, err);
       throw err;
     }
     try {
       here = await importTask(bundle);
     } catch (err) {
-      await tell(link, `${path}/resume`, { force: true }).catch((e) => {
+      await client.resume(link, mirror.id, { force: true }).catch((e) => {
         throw new Error(
           `${(err as Error).message}; and ${link.hostName} didn't resume it: ${e.message}`
         );
@@ -186,7 +179,7 @@ async function moveIn(mirror: Session): Promise<Session> {
   // "moving" there, which nothing can sign off), the mirror stays, so Move
   // here again comes back to this.
   try {
-    await tell(link, `${path}/moved`, { to: os.hostname() });
+    await client.confirmMoved(link, mirror.id, os.hostname());
   } catch (err) {
     throw new Error(
       `It's running here now, but ${link.hostName} didn't confirm (${(err as Error).message}). Press Move here again to tidy up.`
@@ -197,8 +190,8 @@ async function moveIn(mirror: Session): Promise<Session> {
     mirror.id,
     mirror.host_id
   );
-  forgetHostTasks(link.hostId);
+  client.forget(link.hostId);
   return db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(here.id) as Session;
 }

package/lib/tasks/move-guard.ts

@@ -49,7 +49,7 @@ export function moveRefusal(session: Session): string | null {
     .prepare(
       `SELECT lh_card_id,
          EXISTS (SELECT 1 FROM stack_items WHERE session_id = s.id) AS stacked
-       FROM sessions s WHERE id = ?`
+       FROM session_rows s WHERE id = ?`
     )
     .get(session.id) as
     | { lh_card_id: string | null; stacked: number }