@saadnvd1/agent-os 0.3.517 → 0.3.519

package/lib/orchestrator/task-state.ts

@@ -9,6 +9,7 @@ import { blockedReason } from "../tasks/state";
 import { checkWaitingPatterns, statusDetector } from "../status-detector";
 import { getCheck, putCheck } from "./checks";
 import { cleanRemoteText, hostLink, type HostLink } from "../hosts/remote-api";
+import { heldChatFacts } from "../tasks/held-remote";
 import { hostTasks } from "../tasks/remote";
 import { peerPane } from "../hosts/peer-sessions";
 import { untrusted } from "./untrusted";
@@ -24,21 +25,7 @@ export async function waitingState(
   // its own reading of the task is asked for, fresh.
   const link = hostLink(task.host_id);
   if (link && task.view === "chat") return peerChatWaiting(link, task);
-  if (task.view === "chat") {
-    const reason = blockedReason(saidSinceLastMessage(task.id));
-    // Asked of a worker still running from before a restart, too; one
-    // that can't be reached can't be cleared.
-    const state = await chatStateNow(task.id).catch(() => "unknown");
-    return {
-      blocked: reason === null ? null : untrusted(task.name, reason),
-      waitingOn:
-        state === "waiting"
-          ? "an approval or question in its chat"
-          : state === "unknown"
-            ? "its chat worker couldn't be reached, so an open approval or question can't be ruled out"
-            : null,
-    };
-  }
+  if (task.view === "chat") return localChatWaiting(task);
   // A linked machine reads its own screens: asked, and an answer it can't
   // give is a screen that can't be cleared.
   let tail: string;
@@ -71,6 +58,26 @@ export async function waitingState(
   };
 }
 
+// A chat task whose conversation is in this machine's store (or, for a held
+// task, the one the holder asks about).
+export async function localChatWaiting(
+  task: Pick<Session, "id" | "name">
+): Promise<{ blocked: string | null; waitingOn: string | null }> {
+  const reason = blockedReason(saidSinceLastMessage(task.id));
+  // Asked of a worker still running from before a restart, too; one
+  // that can't be reached can't be cleared.
+  const state = await chatStateNow(task.id).catch(() => "unknown");
+  return {
+    blocked: reason === null ? null : untrusted(task.name, reason),
+    waitingOn:
+      state === "waiting"
+        ? "an approval or question in its chat"
+        : state === "unknown"
+          ? "its chat worker couldn't be reached, so an open approval or question can't be ruled out"
+          : null,
+  };
+}
+
 async function peerChatWaiting(
   link: HostLink,
   task: Session
@@ -79,6 +86,24 @@ async function peerChatWaiting(
     blocked: `its chat on ${link.hostName} couldn't be read, so a BLOCKED: line or open question can't be ruled out`,
     waitingOn: null,
   };
+  // A task its orchestrator moved is asked about directly: the whole task
+  // list is slow, and a miss there reads as unread.
+  const facts = task.started_by ? await heldChatFacts(task) : null;
+  if (facts) {
+    const { turn } = facts;
+    return {
+      blocked: facts.blocked ? untrusted(task.name, facts.blocked) : null,
+      waitingOn:
+        turn === "waiting"
+          ? `an approval or question in its chat on ${link.hostName}`
+          : turn === null ||
+              turn === "running" ||
+              turn === "idle" ||
+              turn === "error"
+            ? null
+            : `its chat on ${link.hostName} couldn't say whether a question is open`,
+    };
+  }
   const view = await hostTasks(link, true)
     .then(({ tasks, capabilities }) =>
       // One that can't say its chat's turn can't rule out an open question.

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/security/demo.ts

@@ -56,6 +56,7 @@ export const STATIC_SIBLINGS = [
   "clone",
   "detect",
   "done-idle",
+  "held-replies",
   "import",
   "init",
   "init-script",

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/status-detector.ts

@@ -537,6 +537,10 @@ class SessionStatusDetector {
     if (this.peersAsked.has(hostId)) return;
     this.peersAsked.add(hostId);
     this.hostListedAt.set(hostId, Date.now());
+    // What its held tasks have said to their orchestrators here.
+    void import("./tasks/held-replies")
+      .then((m) => m.pullHeldReplies(link))
+      .catch(() => undefined);
     void peerTmuxSessions(link)
       .then(
         (list) => {

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,109 @@
+/**
+ * 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 {
+  cleanRemoteBlock,
+  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 }));
+  // Whole lines, as a local read has them (read.ts caps and trims them).
+  return typeof text === "string" ? cleanRemoteBlock(text, 16000) : null;
+}
+
+/**
+ * What its chat says about being blocked or asking, as that machine reads it
+ * (the same reading a local chat task gets). Null when it can't be asked,
+ * which callers treat as unread, never as clear.
+ */
+export async function heldChatFacts(
+  task: Pick<Session, "id" | "host_id">
+): Promise<{ blocked: string | null; turn: string | null } | null> {
+  const link = requireHostLink(task.host_id);
+  const res = await hostApi<{ blocked?: unknown; turn?: unknown }>(
+    link,
+    path(task.id, "chat-facts"),
+    { timeout: 10000 }
+  ).catch(() => null);
+  if (!res || (res.blocked !== null && typeof res.blocked !== "string"))
+    return null;
+  if (res.turn !== null && typeof res.turn !== "string") return null;
+  return {
+    blocked: res.blocked ? cleanRemoteBlock(res.blocked, 2000) : null,
+    turn: res.turn,
+  };
+}
+
+/** 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-replies.ts

@@ -0,0 +1,106 @@
+/**
+ * What the tasks this machine's orchestrators moved to a linked machine say
+ * to those orchestrators. That machine only stores the messages (bus/held-reply);
+ * this machine, which polls, pulls them and delivers each as that task's own
+ * message to the orchestrator that started it. Who receives it is this
+ * machine's own record (started_by), never anything the other machine names.
+ */
+
+import { db, type Session } from "../db";
+import { sendMessage } from "../bus";
+import { hostApi, type HostLink } from "../hosts/remote-api";
+
+const PULL_EVERY_MS = 5000;
+const MISSING_FOR_MS = 10 * 60 * 1000;
+const MAX_BODY = 8000;
+
+const g = globalThis as unknown as {
+  __agentosRepliesAt?: Map<string, number>;
+  __agentosRepliesBusy?: Set<string>;
+};
+const lastAsked = (g.__agentosRepliesAt ??= new Map());
+const busy = (g.__agentosRepliesBusy ??= new Set());
+
+interface Pulled {
+  id: number;
+  fromId: string;
+  body: string;
+}
+
+const heldMirror = (hostId: string, id: string) =>
+  db
+    .prepare(
+      `SELECT * FROM sessions WHERE id = ? AND host_id = ?
+         AND started_by IS NOT NULL AND task_status IN ('running', 'moving')`
+    )
+    .get(id, hostId) as Session | undefined;
+
+export function hasHeldMirrors(hostId: string): boolean {
+  return !!db
+    .prepare(
+      `SELECT 1 FROM sessions WHERE host_id = ? AND started_by IS NOT NULL
+         AND task_prompt IS NOT NULL AND task_status IN ('running', 'moving')`
+    )
+    .get(hostId);
+}
+
+/** Delivers what the link's machine holds for this machine's orchestrators. */
+export async function pullHeldReplies(link: HostLink): Promise<number> {
+  const hostId = link.hostId;
+  if (busy.has(hostId) || !hasHeldMirrors(hostId)) return 0;
+  const now = Date.now();
+  if (now - (lastAsked.get(hostId) ?? 0) < PULL_EVERY_MS) return 0;
+  lastAsked.set(hostId, now);
+  busy.add(hostId);
+  try {
+    let messages: Pulled[];
+    try {
+      const res = await hostApi<{ messages?: unknown }>(
+        link,
+        "/api/tasks/held-replies",
+        { timeout: 8000 }
+      );
+      messages = (Array.isArray(res.messages) ? res.messages : []).filter(
+        (m): m is Pulled =>
+          !!m &&
+          Number.isSafeInteger(m.id) &&
+          typeof m.fromId === "string" &&
+          typeof m.body === "string"
+      );
+    } catch (err) {
+      // A machine that predates replies: leave it alone for a while.
+      if ((err as { status?: number }).status === 404)
+        lastAsked.set(hostId, now + MISSING_FOR_MS);
+      return 0;
+    }
+    const handled: number[] = [];
+    let delivered = 0;
+    for (const m of messages) {
+      const mirror = heldMirror(hostId, m.fromId);
+      if (!mirror) {
+        handled.push(m.id); // nothing here to deliver it from
+        continue;
+      }
+      try {
+        await sendMessage({
+          fromId: mirror.id,
+          to: mirror.started_by!,
+          body: m.body.slice(0, MAX_BODY),
+          relayKey: `${hostId}:${m.id}`,
+        });
+        handled.push(m.id);
+        delivered++;
+      } catch {
+        // Gone, or rate limited: offered again at the next pull.
+      }
+    }
+    if (handled.length)
+      await hostApi(link, "/api/tasks/held-replies", {
+        body: { ids: handled },
+        timeout: 8000,
+      }).catch(() => undefined);
+    return delivered;
+  } finally {
+    busy.delete(hostId);
+  }
+}

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,29 @@ 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 = ?,
+             held_for = ?, held_for_name = ?,
+             model_provider = ?, model_overrides = ? WHERE id = ?`
+        ).run(
+          holder,
+          orch.heldFrom,
+          orch.orchestrator?.id ?? null,
+          orch.orchestrator?.name ?? null,
+          orch.modelProvider,
+          orch.modelOverrides,
+          id
+        );
+    }
+    carryTaskState(bundle.moveId, id);
   })();
 
   stepProgress(bundle.moveId, "resume");
@@ -150,9 +206,8 @@ async function arrive(bundle: TaskBundle): Promise<Session> {
         });
       }, `setup-moved-${bundle.branch}`);
     }
-    const prompt = claude
-      ? arrivalNote(bundle, worktreePath)
-      : `${bundle.prompt}\n\n${arrivalNote(bundle, worktreePath)}`;
+    const note = arrivalNote(bundle, worktreePath, os.hostname());
+    const prompt = claude ? note : `${bundle.prompt}\n\n${note}`;
     if (bundle.chat) {
       // Its worker starts on the carried conversation, takes the note
       // first, then what was queued.