@saadnvd1/agent-os 0.3.516 → 0.3.518

package/lib/orchestrator/read.ts

@@ -10,6 +10,7 @@ import { hostLink } from "../hosts/remote-api";
 import { peerPane } from "../hosts/peer-sessions";
 import { workspaceSessions } from "./facts";
 import { untrusted } from "./untrusted";
+import { heldChatTail } from "../tasks/held-remote";
 import {
   findExternalSession,
   knownExternalSession,
@@ -104,6 +105,12 @@ export function chatText(items: ChatItem[]): string {
     .join("\n");
 }
 
+// The last lines of a chat task's conversation, unwrapped.
+export function chatTailText(sessionId: string, lines = DEFAULT_LINES): string {
+  const n = Math.max(1, Math.min(Math.floor(lines) || DEFAULT_LINES, 400));
+  return tail(chatText(lastItems(sessionId, n * 2)), n);
+}
+
 export async function readSession(
   workspaceId: string,
   ref: string,
@@ -121,8 +128,13 @@ export async function readSession(
     return readExternal(external, n);
   }
   const link = hostLink(s.host_id);
-  if (s.view === "chat" && link)
-    return `${s.name} (chat on ${link.hostName}): its messages are on that machine; open it to read them.`;
+  if (s.view === "chat" && link) {
+    // Its orchestrator's task is read through the machine that holds it.
+    const text = s.started_by ? await heldChatTail(s, n) : null;
+    return text
+      ? `${s.name} (chat on ${link.hostName}), last ${n} lines:\n${untrusted(s.name, text)}`
+      : `${s.name} (chat on ${link.hostName}): its messages are on that machine; open it to read them.`;
+  }
   if (s.view === "chat") {
     const text = chatText(lastItems(s.id, n * 2));
     const body = text ? untrusted(s.name, tail(text, n)) : "(no messages yet)";

package/lib/orchestrator/review.ts

@@ -10,6 +10,7 @@
  * the orchestrator hears the verdict as an event.
  */
 
+import { pushReviewBlocked, pushReviewReady } from "../notify/push/events";
 import { db, type Session } from "../db";
 import { amendmentsOf } from "./amendments";
 import type { TaskPR } from "../tasks/state";
@@ -275,6 +276,8 @@ export async function reviewAt(
     .then((done) => {
       if (done.status === "pass" && target.task)
         noteQuickReview(target.task, sha);
+      if (done.status === "pass") pushReviewReady(target.id, sha);
+      else if (done.status === "block") pushReviewBlocked(target.id, sha);
       const said =
         done.status === "pass"
           ? "passed"

package/lib/orchestrator/serve.ts

@@ -4,6 +4,7 @@ import { getWorkspace } from "../workspaces";
 import {
   done,
   drop,
+  moveTaskTo,
   send,
   stack,
   stackStatus,
@@ -46,6 +47,7 @@ const ACTING = new Set<ToolName>([
   "stack",
   "land",
   "drop",
+  "move",
   "stop",
   "done",
   "review",
@@ -156,6 +158,10 @@ export async function runTool(
       const a = p(tool, raw);
       return drop(w, a.task, a.reason);
     }
+    case "move": {
+      const a = p(tool, raw);
+      return moveTaskTo(w, a.task, a.machine);
+    }
     case "stop":
       return stop(w, p(tool, raw).session);
     case "done":

package/lib/orchestrator/shell-guard.ts

@@ -211,6 +211,20 @@ const PULL_MERGE = /(^|\/)pulls\/[^/?\s]+\/merge\/?(\?|$)/;
 
 const MERGE_MSG = `Refused: a PR merges only through the gates: ${T.sign_off} (or ${T.arm}) for a task's or an external PR, ${T.land} for a stack. Nothing merges, closes or retargets a PR from the shell.`;
 
+// aos move, done, stop and drop reach a session by name, past the tools'
+// Pause check and logging; the tools do the same work.
+function aosRefusal(args: string[]): string | null {
+  const [sub] = positionals(args);
+  const tool: Record<string, string> = {
+    move: T.move,
+    done: T.done,
+    stop: T.stop,
+  };
+  if (sub && tool[sub])
+    return `Refused: \`aos ${sub}\` isn't for you; use ${tool[sub]}, which is scoped to this workspace and held by Pause.`;
+  return null;
+}
+
 // gh: pr merge, close and edit --base, and api calls that merge or change a
 // pull request.
 function ghRefusal(args: string[]): string | null {
@@ -522,6 +536,7 @@ export async function shellRefusal(
         secretRefusal(inv, cwd) ??
         (inv.name === "gh" ? ghRefusal(inv.args) : null) ??
         (inv.name === "curl" ? curlRefusal(inv.args) : null) ??
+        (inv.name === "aos" ? aosRefusal(inv.args) : null) ??
         (inv.name === "git" ? await gitRefusal(inv.args, ctx, cwd) : null) ??
         (inv.name === "sqlite3"
           ? await sqliteRefusal(inv, ctx, cwd, command)

package/lib/orchestrator/tool-names.ts

@@ -23,6 +23,7 @@ export const TOOL_NAMES = {
   stack_status: name("stack_status"),
   land: name("land"),
   drop: name("drop"),
+  move: name("move"),
   stop: name("stop"),
   done: name("done"),
   add_project: name("add_project"),

package/lib/orchestrator/tool-schemas.ts

@@ -193,6 +193,17 @@ export const TOOL_SHAPES = {
   stack_status: { id: stackId },
   land: { id: stackId },
   drop: { task, reason: z.string().trim().min(1).max(2000) },
+  move: {
+    task,
+    machine: z
+      .string()
+      .trim()
+      .min(1)
+      .max(200)
+      .describe(
+        'A linked machine\'s name (see Machines), or "here" to bring the task back'
+      ),
+  },
   stop: { session },
   done: { session },
   add_project: {

package/lib/orchestrator/tools.ts

@@ -76,6 +76,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   stack_status: "One stack's items, PRs and progress.",
   land: "Merge a whole stack bottom-up, each PR through the sign-off gates at its current head.",
   drop: "Reject a task: close its PR and remove its worktree. A task still waiting in the queue is removed by its id. Logged with the reason.",
+  move: 'Carry a running task to a linked machine, or back with "here": for heavy test or build work. It keeps its branch, conversation and plan; the gates, events, read, send, stop, done and drop work the same wherever it runs, and the machine it lands on can\'t merge it. Takes a few minutes and runs in the background; an event says when it lands. Refused while paused, for a task waiting on Saad (an escalation or open ask), and for card and stacked tasks.',
   stop: "Stop a session's agent mid-turn, even while it's thinking, keeping its conversation, worktree and branch; your next message runs as its next turn.",
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
   add_project:

package/lib/program-status/tap.ts

@@ -24,7 +24,9 @@ import {
   applyProgramReport,
   dropProgramTransient,
   programSessions,
+  programSummary,
 } from "./store";
+import { noteWaiting } from "../notify/push/waiting";
 
 const execFileAsync = promisify(execFile);
 const tmux = (args: string[]) =>
@@ -85,7 +87,15 @@ async function handle(name: string, event: OscEvent): Promise<void> {
             ? await foreground(name)
             : undefined
         );
-  if (changed) notifyStatusChanged();
+  if (changed) {
+    notifyStatusChanged();
+    const id = (
+      getDb()
+        .prepare(`SELECT id FROM sessions WHERE tmux_name = ?`)
+        .get(name) as { id: string } | undefined
+    )?.id;
+    if (id) noteWaiting(id, programSummary(name)?.state === "blocked");
+  }
 }
 
 // What one pane has said but isn't applied yet: the latest report per

package/lib/schedules/start.ts

@@ -237,7 +237,11 @@ function notify(schedule: Schedule, why: string, paused?: boolean): void {
     const text = `Schedule "${schedule.name}" is paused: ${why}. Point it at another session or delete it.`;
     console.error(`[schedules] ${text}`);
     addNote(schedule.workspace_id, text, "pause");
-    notifyPhone(`schedule:${schedule.id}`, text);
+    notifyPhone(`schedule:${schedule.id}`, text, {
+      category: "system",
+      key: `system:schedule:${schedule.id}:${Date.now()}`,
+      collapse: `system:schedule:${schedule.id}`,
+    });
     return;
   }
   console.error(`[schedules] ${schedule.name} failed: ${why}`);
@@ -248,7 +252,12 @@ function notify(schedule: Schedule, why: string, paused?: boolean): void {
   );
   notifyPhone(
     `schedule:${schedule.id}`,
-    `Schedule "${schedule.name}" failed: ${why}`
+    `Schedule "${schedule.name}" failed: ${why}`,
+    {
+      category: "system",
+      key: `system:schedule:${schedule.id}:${Date.now()}`,
+      collapse: `system:schedule:${schedule.id}`,
+    }
   );
 }
 

package/lib/security/devices.ts

@@ -86,13 +86,52 @@ export function touchDevice(id: string, address?: string): boolean {
   return true;
 }
 
-export function listDevices(): Device[] {
-  return getDb()
+/** What the Devices page shows of a device's push: never the token. */
+export interface DevicePushView {
+  enabled: boolean;
+  categories: PushCategory[];
+  lastError: string | null;
+  updatedAt: string | null;
+}
+
+export type ListedDevice = Device & { push: DevicePushView };
+
+export function listDevices(): ListedDevice[] {
+  const rows = getDb()
     .prepare(
-      `SELECT id, name, user_agent, created_at, last_seen_at, last_address, revoked_at, can_approve
+      `SELECT id, name, user_agent, created_at, last_seen_at, last_address, revoked_at, can_approve,
+         ${PUSH_COLS}
        FROM devices WHERE revoked_at IS NULL ORDER BY created_at DESC`
     )
-    .all() as Device[];
+    .all() as (Device & PushRow)[];
+  return rows.map((r) => {
+    const {
+      push_token,
+      push_platform,
+      push_environment,
+      push_categories,
+      push_updated_at,
+      push_last_error,
+      ...device
+    } = r;
+    const push = pushOf({
+      push_token,
+      push_platform,
+      push_environment,
+      push_categories,
+      push_updated_at,
+      push_last_error,
+    });
+    return {
+      ...device,
+      push: {
+        enabled: !!push,
+        categories: push?.categories ?? [],
+        lastError: push_last_error,
+        updatedAt: push?.updatedAt ?? null,
+      },
+    };
+  });
 }
 
 export function renameDevice(id: string, name: string): boolean {
@@ -301,3 +340,17 @@ function dropDeviceSockets(id: string): void {
   for (const s of sockets.get(id) ?? []) s.destroy();
   sockets.delete(id);
 }
+
+/**
+ * The relay said this token is dead: forget it, keep the chosen categories,
+ * say why. The app registers a fresh token on its next launch.
+ */
+export function pruneDevicePush(id: string, reason: string): void {
+  getDb()
+    .prepare(
+      `UPDATE devices SET push_token = NULL, push_platform = NULL,
+         push_environment = NULL, push_last_error = ?
+       WHERE id = ?`
+    )
+    .run(reason.slice(0, 200), id);
+}

package/lib/sessions/stop.ts

@@ -2,6 +2,7 @@ import { endTmuxSession } from "../tmux/end";
 import { hostLink } from "../hosts/remote-api";
 import { stopChatTurn } from "../chat/stop";
 import type { Session } from "../db";
+import { stopHeldTask } from "../tasks/held-remote";
 
 // Stops a session's agent and keeps everything else, the same for every
 // caller (the orchestrator's stop tool, `aos stop`): a chat's turn ends
@@ -9,8 +10,21 @@ import type { Session } from "../db";
 // and conversation stay, and the next message runs as the next turn. Throws
 // when the chat can't be shown to have stopped.
 export async function stopSession(
-  s: Pick<Session, "id" | "name" | "view" | "host_id" | "tmux_name">
+  s: Pick<
+    Session,
+    | "id"
+    | "name"
+    | "view"
+    | "host_id"
+    | "tmux_name"
+    | "started_by"
+    | "task_prompt"
+  >
 ): Promise<string> {
+  // A task its orchestrator moved to a linked machine stops through that
+  // machine's AgentOS, chat or terminal.
+  if (s.started_by && s.task_prompt && hostLink(s.host_id))
+    return stopHeldTask(s);
   if (s.view === "chat") {
     if (hostLink(s.host_id))
       throw new Error(

package/lib/tasks/branch-worktree.ts

@@ -8,6 +8,7 @@ import fs from "fs";
 import path from "path";
 import { getRepoName, slugify } from "../git";
 import { WORKTREES_DIR } from "../worktrees";
+import { installWorktreeHooks } from "../worktree-hooks";
 import { git as runGit } from "../git-exec";
 import { pushedRef } from "./move";
 
@@ -39,7 +40,21 @@ export function worktreeDirFor(
   return dir;
 }
 
-export async function checkoutBranchWorktree(
+// The hook that strips attribution from commit messages, as every worktree
+// AgentOS makes has (best effort: a worktree without it still works).
+const withHooks = async (r: { worktreePath: string; reused: boolean }) => {
+  await installWorktreeHooks(r.worktreePath).catch((err) =>
+    console.error(`[worktrees] hooks not installed in ${r.worktreePath}:`, err)
+  );
+  return r;
+};
+
+export const checkoutBranchWorktree = async (
+  projectPath: string,
+  branch: string
+) => withHooks(await checkoutBranch(projectPath, branch));
+
+async function checkoutBranch(
   projectPath: string,
   branch: string
 ): Promise<{ worktreePath: string; reused: boolean }> {

package/lib/tasks/finish.ts

@@ -9,9 +9,11 @@ import {
 import { republishAfterMerge } from "../lumifyhub/publish";
 import { restackAfterMerge } from "../stacks/restack";
 import { itemName, liveChildren, signOffRefusal } from "../stacks/guard";
+import { holderRefusal } from "./held";
 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 {
   mergePolicy,
@@ -110,11 +112,14 @@ async function finishMerge(
 // machine merged it and didn't say).
 export async function signOffTask(
   id: string,
-  opts: { wait?: boolean; head?: string } = {}
+  opts: { wait?: boolean; head?: string; device?: string | null } = {}
 ): Promise<MergeMethod | null> {
   const session = getTaskSession(id);
   if (session.task_status !== "running")
     throw new Error(`Task is already ${session.task_status}`);
+  // A task another machine's orchestrator moved here merges only from there.
+  const held = holderRefusal(session, opts.device);
+  if (held) throw new Error(held);
   // 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);
@@ -155,6 +160,7 @@ export async function signOffTask(
     signingOff.delete(id);
   }
   syncTaskCardInBackground(session, "merged", pr);
+  pushMerged(id);
   // Reads the plan file now: cleanup below removes the worktree.
   void captureMergedTask(id, { head: opts.head ?? pr!.head ?? null });
   const head = opts.head ?? pr!.head;

package/lib/tasks/held-remote.ts

@@ -0,0 +1,80 @@
+/**
+ * An orchestrator's calls on a task it moved to a linked machine, which that
+ * machine's AgentOS answers for the device that sent the task (held.ts). The
+ * orchestrator polls and calls; the other machine never reaches back.
+ */
+
+import type { Session } from "../db";
+import { cleanRemoteText, hostApi, requireHostLink } from "../hosts/remote-api";
+import type { Delivery } from "../bus/delivery";
+
+const path = (id: string, leaf: string) =>
+  `/api/tasks/${encodeURIComponent(id)}/${leaf}`;
+
+/**
+ * Delivered by that machine's AgentOS as a message from the orchestrator,
+ * never as the user's own. Keyed by the stored message, so a retry that
+ * already landed is not typed twice.
+ */
+export async function relayToHeldTask(
+  to: Session,
+  line: string,
+  fromName: string,
+  messageId?: number
+): Promise<Delivery> {
+  try {
+    const link = requireHostLink(to.host_id);
+    const { state } = await hostApi<{ state?: unknown }>(
+      link,
+      path(to.id, "message"),
+      {
+        body: {
+          id: messageId ? `bus-${messageId}` : undefined,
+          line,
+          from: fromName,
+        },
+        timeout: 20000,
+      }
+    );
+    return { state: state === "queued" ? "queued" : "delivered" };
+  } catch (error) {
+    const why = error instanceof Error ? error.message : String(error);
+    return { state: "failed", why: why.slice(0, 300) };
+  }
+}
+
+/** A held chat task's last lines of conversation, as that machine reads them. */
+export async function heldChatTail(
+  task: Session,
+  lines: number
+): Promise<string | null> {
+  const link = requireHostLink(task.host_id);
+  const { text } = await hostApi<{ text?: unknown }>(
+    link,
+    `${path(task.id, "chat-tail")}?lines=${lines}`,
+    { timeout: 10000 }
+  ).catch(() => ({ text: undefined }));
+  return typeof text === "string" ? cleanRemoteText(text) : null;
+}
+
+/** Stops its agent there; its conversation and worktree are kept. */
+export async function stopHeldTask(
+  task: Pick<Session, "id" | "name" | "host_id">
+): Promise<string> {
+  const link = requireHostLink(task.host_id);
+  const { text } = await hostApi<{ text?: unknown }>(
+    link,
+    path(task.id, "stop"),
+    {
+      body: {},
+      timeout: 30000,
+    }
+  );
+  return cleanRemoteText(text) || `Stopped ${task.name}.`;
+}
+
+/** Done there: its agent stops and its worktree goes. Never a merge. */
+export async function doneHeldTask(task: Session): Promise<void> {
+  const link = requireHostLink(task.host_id);
+  await hostApi(link, path(task.id, "done"), { body: {}, timeout: 120000 });
+}

package/lib/tasks/held-routes.ts

@@ -0,0 +1,33 @@
+/**
+ * The routes only the device that moved a task here may call on it
+ * (held.ts): message, stop, done and read. Each is refused for any other
+ * device, and for a task that isn't held.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { db, type Session } from "../db";
+import { callingDevice } from "../security/device-me";
+import { holderRefusal } from "./held";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+export async function heldRoute(
+  request: NextRequest,
+  { params }: Ctx,
+  run: (task: Session) => Promise<object>
+): Promise<NextResponse> {
+  const id = (await params).id;
+  const task = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+  if (!task?.held_by_device)
+    return NextResponse.json({ error: "No such held task" }, { status: 404 });
+  const refusal = holderRefusal(task, callingDevice(request));
+  if (refusal) return NextResponse.json({ error: refusal }, { status: 403 });
+  try {
+    return NextResponse.json(await run(task));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/lib/tasks/held.ts

@@ -0,0 +1,28 @@
+/**
+ * A task an orchestrator moved here belongs to that orchestrator's machine:
+ * only the device that sent it may merge, arm, move, message or finish it.
+ * Without this a moved task would be a plain task here, merged by anyone with
+ * a green CI, past the gates its orchestrator judges it by.
+ */
+
+import { db, type Session } from "../db";
+
+export function holderRefusal(
+  session: Pick<Session, "held_by_device" | "held_from">,
+  device: string | null | undefined
+): string | null {
+  if (!session.held_by_device) return null;
+  if (device && device === session.held_by_device) return null;
+  return `Its orchestrator on ${session.held_from || "another machine"} decides this; do it from there`;
+}
+
+/** The refusal for the task with this id, or null (also when it's unknown). */
+export function heldRefusal(
+  id: string,
+  device: string | null | undefined
+): string | null {
+  const session = db
+    .prepare(`SELECT held_by_device, held_from FROM sessions WHERE id = ?`)
+    .get(id) as Pick<Session, "held_by_device" | "held_from"> | undefined;
+  return session ? holderRefusal(session, device) : null;
+}

package/lib/tasks/import.ts

@@ -5,7 +5,9 @@
  * again returns the task it made the first time.
  */
 
+import fs from "fs";
 import os from "os";
+import path from "path";
 import { randomUUID } from "crypto";
 import { db, queries, type Session } from "../db";
 import { setupWorktree } from "../env-setup";
@@ -18,6 +20,9 @@ import {
 import { runInBackground } from "../async-operations";
 import { launchClaude } from "../agents/launch";
 import { resolveModelForAgent } from "../model-catalog";
+import { providerFor } from "../models/resolve";
+import { preparePlanDir, PLAN_FILE } from "../models/plan-step";
+import { carryTaskState } from "./move-carry";
 import { buildTaskBrief } from "./brief";
 import { expandHome } from "./session";
 import { ensureProject } from "./project-ref";
@@ -57,7 +62,16 @@ function refuseBusyBranch(projectId: string, branch: string): void {
   if (busy) throw new Error(`${branch} already has a task running here`);
 }
 
-export async function importTask(input: TaskBundle): Promise<Session> {
+export interface ImportOptions {
+  // The paired device that sent an orchestrator's task: it holds the task
+  // here (held.ts). Absent for this machine taking its own task back.
+  holder?: string | null;
+}
+
+export async function importTask(
+  input: TaskBundle,
+  opts: ImportOptions = {}
+): Promise<Session> {
   const bundle = validateBundle(input);
   const done = arrived(bundle.moveId);
   if (done) return done;
@@ -65,13 +79,16 @@ export async function importTask(input: TaskBundle): Promise<Session> {
     throw new InProgressError("It's arriving already");
   importing.add(bundle.moveId);
   try {
-    return await arrive(bundle);
+    return await arrive(bundle, opts);
   } finally {
     importing.delete(bundle.moveId);
   }
 }
 
-async function arrive(bundle: TaskBundle): Promise<Session> {
+async function arrive(
+  bundle: TaskBundle,
+  opts: ImportOptions
+): Promise<Session> {
   const project = await ensureProject(bundle.project);
   const projectPath = expandHome(project.working_directory);
   refuseBusyBranch(project.id, bundle.branch);
@@ -81,12 +98,29 @@ async function arrive(bundle: TaskBundle): Promise<Session> {
     projectPath,
     bundle.branch
   );
+  const orch = bundle.orchestrated;
+  const holder = orch ? (opts.holder ?? null) : null;
+  // Its provider as it was, or this machine says no and the source resumes
+  // it: a task never silently changes provider.
+  const provider = holder
+    ? (orch?.modelProvider ?? null)
+    : ((
+        db
+          .prepare(`SELECT model_provider FROM sessions WHERE id = ?`)
+          .get(bundle.moveId) as { model_provider: string | null } | undefined
+      )?.model_provider ?? null);
+  if (provider) providerFor(provider);
   const claude = bundle.claude;
   const paths = claude && {
     from: { cwd: claude.cwd, home: claude.home },
     to: { cwd: worktreePath, home: os.homedir() },
   };
   stepProgress(bundle.moveId, "conversation");
+  // The plan is never in git: it comes in the bundle.
+  if (orch?.planFile != null) {
+    preparePlanDir(worktreePath);
+    fs.writeFileSync(path.join(worktreePath, PLAN_FILE), orch.planFile);
+  }
   if (claude && paths) {
     await writeTranscript(
       worktreePath,
@@ -97,10 +131,9 @@ async function arrive(bundle: TaskBundle): Promise<Session> {
 
   const id = randomUUID();
   const tmuxName = `claude-${id}`;
-  const model = resolveModelForAgent(
-    "claude",
-    bundle.model || project.default_model
-  );
+  const model = provider
+    ? bundle.model
+    : resolveModelForAgent("claude", bundle.model || project.default_model);
   const baseBranch = bundle.baseBranch ?? "main";
   const brief = buildTaskBrief({ branch: bundle.branch, baseBranch });
   // Checked and written with no await between, so two can't both pass.
@@ -131,6 +164,26 @@ async function arrive(bundle: TaskBundle): Promise<Session> {
          claude_session_id = ?, moved_from = ? WHERE id = ?`
     ).run(bundle.prompt, brief, claude?.sessionId ?? null, bundle.moveId, id);
     if (bundle.chat) unpackChat(id, bundle.chat, paths);
+    if (orch) {
+      db.prepare(
+        `UPDATE sessions SET plan_phase = ?, task_since = ? WHERE id = ?`
+      ).run(orch.planPhase, orch.since, id);
+      // 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)
+        db.prepare(
+          `UPDATE sessions SET held_by_device = ?, held_from = ?,
+             model_provider = ?, model_overrides = ? WHERE id = ?`
+        ).run(
+          holder,
+          orch.heldFrom,
+          orch.modelProvider,
+          orch.modelOverrides,
+          id
+        );
+    }
+    carryTaskState(bundle.moveId, id);
   })();
 
   stepProgress(bundle.moveId, "resume");