@saadnvd1/agent-os 0.3.517 → 0.3.518

package/lib/orchestrator/facts.ts

@@ -7,7 +7,7 @@
 
 import { db, type Session, type StackItemStatus } from "../db";
 import { statusDetector } from "../status-detector";
-import { hostLink } from "../hosts/remote-api";
+import { cleanRemoteText, hostLink } from "../hosts/remote-api";
 import { peerStatus } from "../hosts/peer-sessions";
 import { chatCompacting, chatState } from "../chat/runner";
 import { chatActivityLine, chatStall, type Stall } from "../chat/activity";
@@ -16,11 +16,16 @@ import { needsYou } from "../needs-you";
 import { programSummary } from "../program-status/store";
 import { sessionRowInfo } from "../session-meta";
 import { taskView, type TaskPR, type TaskState } from "../tasks";
-import { storedPR } from "../tasks/session";
+import { prFor, storedPR } from "../tasks/session";
+import { lastActiveOf } from "../tasks/last-active";
+import { hostTasks } from "../tasks/remote";
+import { deriveTaskState } from "../tasks";
+import { waitingState } from "./task-state";
 import { commitTime, repoOf } from "./repo";
 import { CHECKLESS_MS, checklessFor, ciSettleIn } from "./task-state";
 import { repoHasCI } from "./repo-ci";
 import { markStatusDirty } from "../status/dirty";
+import { queueEvent } from "./events";
 
 export type FactStatus = "running" | "waiting" | "idle" | "dead";
 
@@ -68,9 +73,6 @@ export interface SessionFacts {
   } | null;
 }
 
-const sqliteMs = (t: string | null | undefined) =>
-  t ? Date.parse(`${t.replace(" ", "T")}Z`) || 0 : 0;
-
 // Live sessions in the workspace's projects, plus tasks merged in the last
 // hour so their merge still reads. Never an orchestrator or an archived one.
 export function workspaceSessions(
@@ -83,6 +85,8 @@ export function workspaceSessions(
        WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
          -- A linked machine's own sessions are its orchestrator's to run.
          AND s.peer_mirror = 0
+         -- A task another machine's orchestrator moved here is held for it.
+         AND s.held_by_device IS NULL
          AND (s.task_status IS NULL OR s.task_status = 'running'
            OR (s.task_status = 'merged' AND s.updated_at > datetime('now', '-1 hour')))
        ORDER BY s.created_at`
@@ -121,17 +125,6 @@ function stackOf(sessionId: string): SessionFacts["stack"] {
   };
 }
 
-function latestChatAt(sessionId: string): number {
-  const row = db
-    .prepare(
-      `SELECT data FROM chat_items WHERE session_id = ? ORDER BY seq DESC LIMIT 1`
-    )
-    .get(sessionId) as { data: string } | undefined;
-  return row
-    ? ((JSON.parse(row.data) as { createdAt?: number }).createdAt ?? 0)
-    : 0;
-}
-
 export async function statusOf(s: Session): Promise<{
   status: FactStatus;
   activity: string | null;
@@ -251,6 +244,7 @@ async function taskFacts(
     const state = s.task_status === "moved" ? "done" : s.task_status;
     return { state, pr, blocked: null };
   }
+  if (hostLink(s.host_id)) return remoteTaskFacts(workspaceId, s);
   const view = await taskView(s);
   return {
     state: view.state,
@@ -261,6 +255,67 @@ async function taskFacts(
   };
 }
 
+// A task another machine runs: its state is that machine's word (the same
+// reading the gates use), and the PR is read here, from GitHub, by branch.
+// What it can't say reads as blocked, never as clear.
+async function remoteTaskFacts(
+  workspaceId: string,
+  s: Session
+): Promise<NonNullable<SessionFacts["task"]>> {
+  const [pr, waiting] = await Promise.all([
+    prFor(s).catch(() => null),
+    waitingState(s),
+  ]);
+  await announceRemotePlan(workspaceId, s);
+  const status = peerStatus(s.host_id, s.id) ?? "running";
+  const state = deriveTaskState({
+    taskStatus: "running",
+    sessionStatus: status,
+    pr,
+    blocked: waiting.blocked !== null,
+  });
+  return {
+    state,
+    pr,
+    blocked: waiting.blocked,
+    ciSettleIn: await settleIn(workspaceId, s, pr),
+    ciSilentMs: await silentFor(s, pr),
+  };
+}
+
+// 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.
+async function announceRemotePlan(
+  workspaceId: string,
+  s: Session
+): 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);
+  const note =
+    typeof view?.planNote === "string"
+      ? cleanRemoteText(view.planNote).slice(0, 2000)
+      : "";
+  if (!note || note === s.plan_note) return;
+  db.prepare(`UPDATE sessions SET plan_note = ? WHERE id = ?`).run(note, s.id);
+  queueEvent(workspaceId, `plan-done:${s.id}`, s.id, note);
+}
+
+// A task on another machine is as active as that machine says; one it can't
+// reach is taken as active just now, so nothing reads it as abandoned.
+async function lastActiveFor(s: Session): Promise<number> {
+  const link = hostLink(s.host_id);
+  if (!link) return lastActiveOf(s);
+  const view = await hostTasks(link)
+    .then(({ tasks }) => tasks.find((t) => t?.id === s.id))
+    .catch(() => undefined);
+  return typeof view?.lastActiveAt === "number"
+    ? view.lastActiveAt
+    : Date.now();
+}
+
 export async function sessionFacts(
   workspaceId: string
 ): Promise<SessionFacts[]> {
@@ -283,11 +338,7 @@ export async function sessionFacts(
           s.view === "chat" && !hostLink(s.host_id) ? chatStall(s.id) : null,
         compacting:
           s.view === "chat" && !hostLink(s.host_id) && !!chatCompacting(s.id),
-        lastActive: Math.max(
-          sqliteMs(s.updated_at),
-          statusDetector.getTimestamp(s.tmux_name) * 1000,
-          latestChatAt(s.id)
-        ),
+        lastActive: await lastActiveFor(s),
         branch: s.branch_name,
         quick: !!s.quick_of,
         plan:

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/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/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,6 +9,7 @@ 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";
@@ -111,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);

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

package/lib/tasks/index.ts

@@ -58,11 +58,12 @@ import { remoteTaskViews } from "./remote-views";
 import { chatStateNow } from "../chat/runner";
 import { saidSinceLastMessage } from "../chat/store";
 
+import { lastActiveOf } from "./last-active";
 export * from "./state";
 export { codeReviewGate, codeReviewRefusal } from "./code-review";
 export { signOffTask, dropTask, signingOff, mergeSettled } from "./finish";
 export { prFor as taskPR } from "./session";
-export { moveTask } from "./move-flow";
+export { assertMovable, moveTask } from "./move-flow";
 
 export interface TaskView {
   id: string;
@@ -106,6 +107,12 @@ export interface TaskView {
   quickOf?: string | null;
   // What it has cost so far in weighted tokens (lib/usage/weights).
   weighted?: number;
+  // Its last sign of life, in ms, for an orchestrator on another machine.
+  lastActiveAt?: number;
+  // Held for another machine's orchestrator (held.ts): which machine, and
+  // the "plan written" line it would have been told.
+  heldFrom?: string | null;
+  planNote?: string | null;
 }
 
 export async function createTask(opts: {
@@ -394,6 +401,9 @@ export async function taskView(session: Session): Promise<TaskView> {
     planning: session.plan_phase === "planning",
     plan: taskPlan(session),
     quickOf: session.quick_of ?? null,
+    lastActiveAt: session.held_by_device ? lastActiveOf(session) : undefined,
+    heldFrom: session.held_by_device ? (session.held_from ?? null) : null,
+    planNote: session.held_by_device ? (session.plan_note ?? null) : null,
   };
 }