@saadnvd1/agent-os 0.3.637 → 0.3.644

package/lib/tasks/move-recover.ts

@@ -8,38 +8,19 @@
 
 import { db, type Session } from "../db";
 import { hostIdNamed } from "../hosts";
-import { hostApi, hostLink, type HostLink } from "../hosts/remote-api";
+import { hostLink, type HostLink } from "../hosts/remote-api";
 import { getTaskSession } from "./session";
 import { markMoved, resumeTask } from "./move";
-import { forgetHostTasks, mirrorTask, unknownOutcome } from "./remote";
+import * as client from "./contract/client";
+import { mirrorTask } from "./contract/start";
 import { carryTaskState } from "./move-carry";
 
-/** POST, repeated when the outcome is unknown (the calls are idempotent). */
-export async function tell(
-  link: HostLink,
-  path: string,
-  body: object = {}
-): Promise<void> {
-  for (let i = 0; ; i++) {
-    try {
-      await hostApi(link, path, { body });
-      return;
-    } catch (err) {
-      if (!unknownOutcome(err) || i === 2) throw err;
-    }
-  }
-}
-
 /** The task a move from this session made there, or null. Throws if unsure. */
 export async function arrivedThere(
   link: HostLink,
   sessionId: string
 ): Promise<Session | null> {
-  const { session } = await hostApi<{ session: Session | null }>(
-    link,
-    `/api/tasks/arrived?from=${encodeURIComponent(sessionId)}`
-  );
-  return session;
+  return client.arrived(link, sessionId);
 }
 
 export function settleMovedOut(
@@ -53,9 +34,9 @@ export function settleMovedOut(
     mirrorTask(hostId, session.project_id, there);
     carryTaskState(session.id, there.id);
   })();
-  forgetHostTasks(hostId);
+  client.forget(hostId);
   return db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(there.id) as Session;
 }
 

package/lib/tasks/move-testing.ts

@@ -6,7 +6,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { randomUUID } from "crypto";
-import { db, type Session } from "../db";
+import { db, insertSessionRow, type Session } from "../db";
 import { createProject } from "../projects";
 import { writeTranscript } from "./transcript";
 import { gitSync } from "../git-exec";
@@ -17,7 +17,7 @@ export const git = (cwd: string, ...args: string[]) =>
   gitSync(cwd, args).trim();
 
 export const row = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as Session;
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as Session;
 
 export interface MoveFixture {
   tmp: string;
@@ -71,11 +71,20 @@ export async function seedTask(
   git(f.repo, "worktree", "add", "-q", "-b", branch, cwd, "main");
   fs.writeFileSync(path.join(cwd, "work.txt"), "half done\n");
   const id = randomUUID();
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, task_status,
-       task_prompt, branch_name, worktree_path, base_branch, claude_session_id, model)
-     VALUES (?, 'Fix it', ?, ?, ?, 'running', 'fix the thing', ?, ?, 'main', ?, 'sonnet')`
-  ).run(id, `claude-${id}`, cwd, f.projectId, branch, cwd, CLAUDE_ID);
+  insertSessionRow(db, {
+    id,
+    name: "Fix it",
+    tmux_name: `claude-${id}`,
+    working_directory: cwd,
+    project_id: f.projectId,
+    task_status: "running",
+    task_prompt: "fix the thing",
+    branch_name: branch,
+    worktree_path: cwd,
+    base_branch: "main",
+    claude_session_id: CLAUDE_ID,
+    model: "sonnet",
+  });
   await writeTranscript(
     cwd,
     CLAUDE_ID,

package/lib/tasks/move.ts

@@ -36,6 +36,7 @@ import {
   latestSessionId,
   readTranscript,
 } from "./transcript";
+import { setTask } from "../db/session-parts";
 
 export * from "./move-bundle";
 
@@ -88,13 +89,13 @@ async function pushOwnBranch(cwd: string, branch: string): Promise<void> {
  * arrived, and then it would run on both.
  */
 function claimMoving(id: string, to: string): { fresh: boolean } {
-  const fresh = db
-    .prepare(
-      `UPDATE sessions SET task_status = 'moving', moved_to = ?
-         WHERE id = ? AND task_status = 'running'`
-    )
-    .run(to, id);
-  if (fresh.changes === 1) return { fresh: true };
+  const fresh = setTask(
+    db,
+    id,
+    { task_status: "moving", moved_to: to },
+    { task_status: "running" }
+  );
+  if (fresh) return { fresh: true };
   const { task_status, moved_to } = getTaskSession(id);
   if (task_status === "moving" && moved_to === to) return { fresh: false };
   throw new Error(
@@ -250,12 +251,12 @@ export async function exportOrResume(
 }
 
 export function markMoved(id: string, to: string): void {
-  const moved = db
-    .prepare(
-      `UPDATE sessions SET task_status = 'moved', moved_to = ?
-       WHERE id = ? AND task_status IN ('running', 'moving')`
-    )
-    .run(to, id).changes;
+  const moved = setTask(
+    db,
+    id,
+    { task_status: "moved", moved_to: to },
+    { task_status: ["running", "moving"] }
+  );
   // It goes on there with a copy of its own.
   if (moved) void dropSessionDatabase(id);
 }
@@ -269,25 +270,24 @@ export function markMoved(id: string, to: string): void {
  */
 export async function resumeTask(id: string, note?: string): Promise<void> {
   if (exporting.has(id)) throw new Error("It's moving right now");
-  const claimed = db
-    .prepare(
-      `UPDATE sessions SET task_status = 'running' WHERE id = ? AND task_status = 'moving'`
-    )
-    .run(id);
+  const claimed = setTask(
+    db,
+    id,
+    { task_status: "running" },
+    { task_status: "moving" }
+  );
   const session = getTaskSession(id);
-  if (claimed.changes !== 1) {
+  if (!claimed) {
     if (session.task_status === "running") return;
     throw new Error(`Task is already ${session.task_status}`);
   }
   try {
     await relaunch(session, note);
   } catch (err) {
-    db.prepare(
-      `UPDATE sessions SET task_status = 'moving' WHERE id = ? AND task_status = 'running'`
-    ).run(id);
+    setTask(db, id, { task_status: "moving" }, { task_status: "running" });
     throw err;
   }
-  db.prepare(`UPDATE sessions SET moved_to = NULL WHERE id = ?`).run(id);
+  setTask(db, id, { moved_to: null });
 }
 
 async function relaunch(session: Session, note?: string): Promise<void> {

package/lib/tasks/moved-away.ts

@@ -12,7 +12,7 @@ import { settleWorktree, type WorktreeFate } from "../done/worktree";
 import { archiveSession } from "../done/archive";
 
 export async function cleanUpMovedAway(id: string): Promise<WorktreeFate> {
-  const s = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  const s = db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
   if (!s || s.task_status !== "moved" || !s.held_by_device)

package/lib/tasks/pause-hold.ts

@@ -2,6 +2,7 @@
 // can hold a message for it without loading the pause machinery.
 
 import { db, type TaskPause } from "../db";
+import { setPause } from "../db/session-parts";
 
 export interface PauseHold {
   pauseId: number;
@@ -11,7 +12,7 @@ export interface PauseHold {
 export function pauseHoldOf(sessionId: string): PauseHold | null {
   const row = db
     .prepare(
-      `SELECT pause_id, paused_until FROM sessions
+      `SELECT pause_id, paused_until FROM session_rows
        WHERE id = ? AND pause_state IN ('pausing', 'paused') AND pause_id IS NOT NULL`
     )
     .get(sessionId) as
@@ -45,10 +46,17 @@ export function endPause(
       `UPDATE task_pauses SET state = 'ended', ended_at = datetime('now'), end_reason = ?
        WHERE id = ? AND state != 'ended'`
     ).run(reason, row.id);
-    db.prepare(
-      `UPDATE sessions SET pause_state = NULL, paused_until = NULL, pause_id = NULL, pause_note = NULL
-       WHERE id = ? AND pause_id = ?`
-    ).run(row.session_id, row.id);
+    setPause(
+      db,
+      row.session_id,
+      {
+        pause_state: null,
+        paused_until: null,
+        pause_id: null,
+        pause_note: null,
+      },
+      { pause_id: row.id }
+    );
   })();
 }
 

package/lib/tasks/pause.ts

@@ -50,6 +50,7 @@ import {
   type PauseView,
   type Priority,
 } from "./schedule-types";
+import { setPause } from "../db/session-parts";
 
 export class PauseRefused extends Error {}
 
@@ -72,7 +73,7 @@ const nudge = () =>
   void import("./queue").then((q) => q.tickQueueSoon()).catch(() => undefined);
 
 const sessionOf = (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;
 
@@ -165,10 +166,9 @@ export function requestPause(sessionId: string, req: PauseRequest): TaskPause {
       until ? toSqliteTime(until) : null,
       existing.id
     );
-    db.prepare(`UPDATE sessions SET paused_until = ? WHERE id = ?`).run(
-      until ? toSqliteTime(until) : null,
-      sessionId
-    );
+    setPause(db, sessionId, {
+      paused_until: until ? toSqliteTime(until) : null,
+    });
     // "Pause now" takes over: the first driver is superseded, not raced.
     drive(sessionId, existing.id, mode === "now");
     return pauseRow(existing.id)!;
@@ -190,9 +190,11 @@ export function requestPause(sessionId: string, req: PauseRequest): TaskPause {
         until ? toSqliteTime(until) : null
       ).lastInsertRowid
   );
-  db.prepare(
-    `UPDATE sessions SET pause_state = 'pausing', paused_until = ?, pause_id = ? WHERE id = ?`
-  ).run(until ? toSqliteTime(until) : null, id, sessionId);
+  setPause(db, sessionId, {
+    pause_state: "pausing",
+    paused_until: until ? toSqliteTime(until) : null,
+    pause_id: id,
+  });
   drive(sessionId, id);
   return pauseRow(id)!;
 }
@@ -307,10 +309,7 @@ function markPaused(sessionId: string, pauseId: number): void {
          WHERE id = ? AND state = 'pausing'`
       )
       .run(pauseId).changes;
-    if (n)
-      db.prepare(`UPDATE sessions SET pause_state = 'paused' WHERE id = ?`).run(
-        sessionId
-      );
+    if (n) setPause(db, sessionId, { pause_state: "paused" });
     return n;
   })();
   if (!changed) return;
@@ -359,10 +358,7 @@ export function setResumeTime(sessionId: string, until: Date | null): void {
     db.prepare(
       `UPDATE task_pauses SET until_at = ?, resume_requested_at = NULL WHERE id = ? AND state IN ('pausing','paused')`
     ).run(value, row.id);
-    db.prepare(`UPDATE sessions SET paused_until = ? WHERE id = ?`).run(
-      value,
-      sessionId
-    );
+    setPause(db, sessionId, { paused_until: value });
   })();
 }
 
@@ -396,9 +392,11 @@ export function requestResume(sessionId: string, actor: PauseBy): void {
 export { loadHoldFor, resumeHoldFor };
 
 export function setPauseNote(sessionId: string, note: string | null): void {
-  db.prepare(
-    `UPDATE sessions SET pause_note = ? WHERE id = ? AND pause_state = 'paused' AND COALESCE(pause_note, '') != COALESCE(?, '')`
-  ).run(note, sessionId, note);
+  const row = db
+    .prepare(`SELECT pause_note FROM session_rows WHERE id = ?`)
+    .get(sessionId) as { pause_note: string | null } | undefined;
+  if ((row?.pause_note ?? "") === (note ?? "")) return;
+  setPause(db, sessionId, { pause_note: note }, { pause_state: "paused" });
 }
 
 export type ResumeOutcome =
@@ -453,7 +451,7 @@ export function dueResumes(): DueResume[] {
     .prepare(
       `SELECT p.id AS pause_id, p.session_id, p.by_kind, p.until_at, p.resume_requested_at, p.resume_by_kind,
               s.project_id, s.priority
-       FROM task_pauses p JOIN sessions s ON s.id = p.session_id
+       FROM task_pauses p JOIN session_rows s ON s.id = p.session_id
        WHERE p.state = 'paused' AND p.resume_requested_at IS NOT NULL
          AND s.task_status IN ('running') AND s.archived_at IS NULL`
     )
@@ -583,9 +581,7 @@ export async function claimResume(
         }),
         Date.now()
       );
-    db.prepare(
-      `UPDATE sessions SET pause_state = 'resuming', pause_note = NULL WHERE id = ?`
-    ).run(sessionId);
+    setPause(db, sessionId, { pause_state: "resuming", pause_note: null });
     return true;
   })();
   if (!claimed) return "gone";

package/lib/tasks/plan-view.ts

@@ -18,7 +18,7 @@ import {
 } from "./loop-types";
 import { expandHome } from "./session";
 import { isRemoteHost } from "../hosts";
-import { remotePlanPath } from "./remote-plan-path";
+import { remotePlanPath } from "./contract/plan-path";
 
 const TITLE_MAX = 120;
 

package/lib/tasks/pr-activity.ts

@@ -275,9 +275,19 @@ export async function failedLog(
   repo: Repo,
   url: string | null | undefined
 ): Promise<FailedLog | null> {
+  const raw = await failedJobLog(dir, repo, url);
+  return raw === null ? null : trimLog(raw);
+}
+
+// The same log whole, as gh prints it.
+export async function failedJobLog(
+  dir: string,
+  repo: Repo,
+  url: string | null | undefined
+): Promise<string | null> {
   const job = jobOf(url);
   if (!job) return null;
-  const raw = await run(
+  return run(
     "gh",
     [
       "run",
@@ -291,5 +301,4 @@ export async function failedLog(
     dir,
     60000
   );
-  return trimLog(raw);
 }

package/lib/tasks/prune-branches.ts

@@ -0,0 +1,193 @@
+// `aos branches prune`: the stale remote branches AgentOS tasks left behind.
+// A branch is stale when it is a task's recorded branch, its latest PR is
+// merged or closed at the branch's current commit, and no open PR builds on
+// it. Dry run by default; deleting goes through the same checks as a merge.
+
+import { db } from "../db";
+import { run } from "./gh";
+import { PROTECTED_BRANCHES, deleteTaskBranch } from "./remote-branch";
+
+export interface PruneRepo {
+  dir: string;
+  slug: string;
+  projectIds: string[];
+}
+
+export interface StaleBranch {
+  branch: string;
+  pr: number;
+  state: "MERGED" | "CLOSED";
+  head: string;
+}
+
+export interface RepoPrune {
+  slug: string;
+  stale: StaleBranch[];
+  kept: { branch: string; why: string }[];
+  deleted: string[];
+}
+
+interface ListedPR {
+  number: number;
+  state: string;
+  headRefName: string;
+  headRefOid: string;
+  baseRefName: string;
+  isCrossRepository: boolean;
+}
+
+const taskBranches = (projectIds: string[]): Set<string> => {
+  if (!projectIds.length) return new Set();
+  const rows = db
+    .prepare(
+      `SELECT DISTINCT branch_name FROM session_rows
+       WHERE branch_name IS NOT NULL
+         AND project_id IN (${projectIds.map(() => "?").join(", ")})`
+    )
+    .all(...projectIds) as { branch_name: string }[];
+  return new Set(rows.map((r) => r.branch_name));
+};
+
+async function remoteBranches(repo: PruneRepo): Promise<Map<string, string>> {
+  const out = await run(
+    "gh",
+    [
+      "api",
+      `repos/${repo.slug}/branches`,
+      "--paginate",
+      "--jq",
+      ".[] | [.name, .commit.sha] | @tsv",
+    ],
+    repo.dir,
+    120000
+  );
+  const tips = new Map<string, string>();
+  for (const line of out.split("\n")) {
+    const [name, sha] = line.split("\t");
+    if (name && sha) tips.set(name, sha);
+  }
+  return tips;
+}
+
+export async function pruneRepo(
+  repo: PruneRepo,
+  opts: { yes?: boolean } = {}
+): Promise<RepoPrune> {
+  const [tips, prsOut, defaultOut] = await Promise.all([
+    remoteBranches(repo),
+    run(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--repo",
+        repo.slug,
+        "--state",
+        "all",
+        "--limit",
+        "1000",
+        "--json",
+        "number,state,headRefName,headRefOid,baseRefName,isCrossRepository",
+      ],
+      repo.dir,
+      120000
+    ),
+    run(
+      "gh",
+      [
+        "repo",
+        "view",
+        repo.slug,
+        "--json",
+        "defaultBranchRef",
+        "--jq",
+        ".defaultBranchRef.name",
+      ],
+      repo.dir,
+      20000
+    ),
+  ]);
+  const prs = JSON.parse(prsOut) as ListedPR[];
+  const defaultBranch = defaultOut.trim();
+  const mine = taskBranches(repo.projectIds);
+  const result: RepoPrune = {
+    slug: repo.slug,
+    stale: [],
+    kept: [],
+    deleted: [],
+  };
+  const keep = (branch: string, why: string) =>
+    result.kept.push({ branch, why });
+
+  for (const [branch, tip] of [...tips].sort()) {
+    if (branch === defaultBranch || PROTECTED_BRANCHES.has(branch)) continue;
+    if (!mine.has(branch)) {
+      keep(branch, "not an AgentOS task's branch");
+      continue;
+    }
+    const own = prs
+      .filter((p) => p.headRefName === branch && !p.isCrossRepository)
+      .sort((a, b) => b.number - a.number);
+    if (!own.length) {
+      keep(branch, "no PR");
+      continue;
+    }
+    const open = prs.find(
+      (p) =>
+        p.state === "OPEN" &&
+        (p.baseRefName === branch ||
+          (p.headRefName === branch && !p.isCrossRepository))
+    );
+    if (open) {
+      keep(branch, `open PR #${open.number}`);
+      continue;
+    }
+    const latest = own[0];
+    if (latest.headRefOid !== tip) {
+      keep(branch, `moved to ${tip.slice(0, 7)} after PR #${latest.number}`);
+      continue;
+    }
+    result.stale.push({
+      branch,
+      pr: latest.number,
+      state: latest.state as StaleBranch["state"],
+      head: latest.headRefOid,
+    });
+  }
+
+  if (opts.yes)
+    for (const s of result.stale) {
+      const out = await deleteTaskBranch({
+        repo: repo.dir,
+        slug: repo.slug,
+        branch: s.branch,
+        prHead: s.head,
+        keep: [defaultBranch],
+      });
+      if (out.deleted) result.deleted.push(s.branch);
+      else keep(s.branch, out.why);
+    }
+  return result;
+}
+
+export function pruneText(results: RepoPrune[], yes: boolean): string {
+  const lines: string[] = [];
+  let total = 0;
+  for (const r of results) {
+    lines.push(`${r.slug}:`);
+    const list = yes ? r.deleted : r.stale.map((s) => s.branch);
+    total += list.length;
+    for (const s of r.stale)
+      if (!yes || r.deleted.includes(s.branch))
+        lines.push(
+          `  ${yes ? "deleted" : "stale"}  ${s.branch}  (PR #${s.pr} ${s.state.toLowerCase()})`
+        );
+    for (const k of r.kept) lines.push(`  kept   ${k.branch}  (${k.why})`);
+  }
+  lines.push(
+    yes
+      ? `Deleted ${total} branch${total === 1 ? "" : "es"}.`
+      : `${total} stale branch${total === 1 ? "" : "es"}. Dry run: aos branches prune --yes deletes them.`
+  );
+  return lines.join("\n");
+}

package/lib/tasks/prune-scope.ts

@@ -0,0 +1,22 @@
+import { getProject } from "../projects";
+import { repoSlug } from "../git-remote";
+import { scopeProjectIds, type DoneScope } from "../done/bulk";
+import { expandHome } from "./session";
+import type { PruneRepo } from "./prune-branches";
+
+// The scope's local GitHub clones, one entry per repository (projects that
+// share one are merged, so its branches are listed once).
+export async function prunableRepos(scope: DoneScope): Promise<PruneRepo[]> {
+  const bySlug = new Map<string, PruneRepo>();
+  for (const id of scopeProjectIds(scope)) {
+    const p = getProject(id);
+    if (!p || (p.host_id && p.host_id !== "local")) continue;
+    const dir = expandHome(p.working_directory);
+    const slug = await repoSlug(dir);
+    if (!slug) continue;
+    const hit = bySlug.get(slug);
+    if (hit) hit.projectIds.push(id);
+    else bySlug.set(slug, { dir, slug, projectIds: [id] });
+  }
+  return [...bySlug.values()];
+}

package/lib/tasks/queue-placement.ts

@@ -10,7 +10,7 @@ import { peerReading, peerSource, refreshPeers } from "../hosts/peer-load";
 import { projectMachines } from "../hosts/project-machines";
 import { viewOf } from "../load/machines";
 import { usesGitCrypt } from "../worktree-add";
-import { hostTasks } from "./remote";
+import { list as hostTasks } from "./contract/client";
 import {
   asPlanPhase,
   place,

package/lib/tasks/queue-rows.ts

@@ -18,7 +18,7 @@ export const row = (id: string) =>
     | undefined;
 
 export const sessionOf = (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;
 
@@ -60,7 +60,7 @@ export function runningIn(
   return (
     db
       .prepare(
-        `SELECT s.id FROM sessions s JOIN projects p ON p.id = s.project_id
+        `SELECT s.id FROM session_rows s JOIN projects p ON p.id = s.project_id
          WHERE ${where} AND s.archived_at IS NULL AND s.quick_of IS NULL
            AND (s.pause_state IS NULL OR s.pause_state != 'paused')
            ${forSlots ? `AND NOT (COALESCE(s.plan_only, 0) = 1 AND COALESCE(s.plan_phase, '') != 'implementing')` : ""}
@@ -127,7 +127,7 @@ export function resolveAfter(
   const scope = workspaceId ? `AND p.workspace_id = @ws` : "";
   const candidates = db
     .prepare(
-      `SELECT s.id, s.name FROM sessions s JOIN projects p ON p.id = s.project_id
+      `SELECT s.id, s.name FROM session_rows s JOIN projects p ON p.id = s.project_id
        WHERE s.archived_at IS NULL AND s.task_status IN ('running', 'moving') ${scope}
        UNION ALL
        SELECT q.id, COALESCE(q.name, q.prompt) AS name FROM task_queue q
@@ -227,7 +227,7 @@ export function lineSignature(): string {
     .prepare(
       `SELECT COUNT(*) AS n, COALESCE(MAX(position), 0) AS p,
               COALESCE(SUM(priority = 'normal'), 0) AS pr,
-              (SELECT COUNT(*) FROM sessions WHERE task_status IS NOT NULL
+              (SELECT COUNT(*) FROM session_rows WHERE task_status IS NOT NULL
                  AND task_status NOT IN ('merged', 'dropped')) AS running
        FROM task_queue WHERE status IN ('queued', 'starting')`
     )

package/lib/tasks/queue-start.ts

@@ -27,6 +27,7 @@ import {
   type QueueRow,
   type StartOutcome,
 } from "./queue-types";
+import { setPlacement, setTask } from "../db/session-parts";
 
 // Tells the orchestrator that queued it that it started.
 export function announce(
@@ -205,7 +206,8 @@ function stampStarted(r: QueueRow, placed: Placement | null): void {
   const priority =
     r.priority && r.priority !== DEFAULT_PRIORITY ? r.priority : null;
   if (!note && !priority) return;
-  db.prepare(
-    `UPDATE sessions SET priority = COALESCE(?, priority), placed_note = COALESCE(?, placed_note) WHERE id = ?`
-  ).run(priority, note, r.id);
+  db.transaction(() => {
+    setTask(db, r.id, { priority: priority ?? undefined });
+    setPlacement(db, r.id, { placed_note: note ?? undefined });
+  })();
 }

package/lib/tasks/queue-tick.ts

@@ -128,8 +128,8 @@ export function tickQueue(): Promise<void> {
   tickState.ticking ??= (async () => {
     try {
       // Plans written on a linked machine, and approved plans coming here.
-      await import("./remote-plan")
-        .then((m) => m.syncRemotePlans())
+      await import("./contract/sync")
+        .then((m) => m.syncMirrors())
         .catch((error: unknown) => console.error("[queue] plans:", error));
       for (let i = 0; i < 3; i++) {
         if ((await tickOnce()) !== "stale") break;