@saadnvd1/agent-os 0.3.517 → 0.3.519

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,
   };
 }
 

package/lib/tasks/last-active.ts

@@ -0,0 +1,25 @@
+// A session's last sign of life, in ms: its row, its tmux pane, its chat.
+
+import { db, type Session } from "../db";
+import { statusDetector } from "../status-detector";
+
+export const sqliteMs = (t: string | null | undefined) =>
+  t ? Date.parse(`${t.replace(" ", "T")}Z`) || 0 : 0;
+
+export 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 const lastActiveOf = (s: Session): number =>
+  Math.max(
+    sqliteMs(s.updated_at),
+    statusDetector.getTimestamp(s.tmux_name) * 1000,
+    latestChatAt(s.id)
+  );

package/lib/tasks/move-bundle.ts

@@ -14,8 +14,10 @@ export const MAX_TRANSCRIPT_BYTES = 64 * 1024 * 1024;
 // whole bundle stays under what a linked machine reads of an answer
 // (lib/hosts/remote-api), since a move back here reads it as one.
 export const MAX_CHAT_BYTES = 12 * 1024 * 1024;
+// A task's plan file is a page or two; this is far past that.
+export const MAX_PLAN_BYTES = 1024 * 1024;
 export const MAX_BUNDLE_BYTES =
-  MAX_TRANSCRIPT_BYTES + MAX_CHAT_BYTES + 1024 * 1024;
+  MAX_TRANSCRIPT_BYTES + MAX_CHAT_BYTES + MAX_PLAN_BYTES + 1024 * 1024;
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 export const isSessionId = (id: unknown): id is string =>
@@ -50,6 +52,28 @@ export interface TaskBundle {
   // A chat task's own state; absent for a terminal task, or from a machine
   // that predates chat moves.
   chat?: ChatBundle;
+  // What a task started by an orchestrator carries besides its work; absent
+  // for any other task, or from a machine that predates these moves.
+  orchestrated?: OrchestratedBundle;
+}
+
+export interface OrchestratedBundle {
+  // The machine whose orchestrator holds the task, for the other machine's
+  // screens and refusals.
+  heldFrom: string;
+  // When the task first started (an ISO time), so a PR opened before the
+  // move still counts as the task's.
+  since: string | null;
+  // The model's provider and a task's own models, as they were; an arriving
+  // machine without that provider refuses the task rather than change it.
+  modelProvider: string | null;
+  modelOverrides: string | null;
+  planPhase: "planning" | "implementing" | null;
+  // .agentos/plan.md, which is never in git.
+  planFile: string | null;
+  // The orchestrator that holds the task (its id and name on the machine
+  // that runs it), so the task can message it from where it runs.
+  orchestrator?: { id: string; name: string };
 }
 
 export interface ChatBundle {
@@ -101,6 +125,47 @@ function validateChat(c: ChatBundle): ChatBundle {
   return { ...c, plan: !!c.plan };
 }
 
+const PHASES = ["planning", "implementing"];
+
+function validateOrchestrated(o: OrchestratedBundle): OrchestratedBundle {
+  if (!o || typeof o !== "object") throw new Error("Bad orchestrated task");
+  if (
+    !isStrOrNull(o.since) ||
+    !isStrOrNull(o.modelProvider) ||
+    !isStrOrNull(o.modelOverrides) ||
+    !isStrOrNull(o.planFile) ||
+    !(o.planPhase === null || PHASES.includes(o.planPhase as string))
+  )
+    throw new Error("Bad orchestrated task");
+  if (o.since !== null && Number.isNaN(Date.parse(o.since)))
+    throw new Error("Bad start time");
+  if ((o.planFile?.length ?? 0) > MAX_PLAN_BYTES)
+    throw new Error("The plan is too large to move");
+  return {
+    heldFrom: String(o.heldFrom || "another machine")
+      .replace(/[^\w.@ -]/g, "")
+      .slice(0, 100),
+    since: o.since,
+    modelProvider: o.modelProvider,
+    modelOverrides: o.modelOverrides,
+    planPhase: o.planPhase,
+    planFile: o.planFile,
+    orchestrator:
+      o.orchestrator &&
+      isSessionId(o.orchestrator.id) &&
+      typeof o.orchestrator.name === "string" &&
+      o.orchestrator.name.trim()
+        ? {
+            id: o.orchestrator.id,
+            name: o.orchestrator.name
+              .replace(/[\u0000-\u001f]/g, " ")
+              .trim()
+              .slice(0, 200),
+          }
+        : undefined,
+  };
+}
+
 export function validateBundle(b: TaskBundle): TaskBundle {
   if (!b || typeof b !== "object") throw new Error("No task to import");
   if (!isSessionId(b.moveId)) throw new Error("Bad move id");
@@ -130,6 +195,9 @@ export function validateBundle(b: TaskBundle): TaskBundle {
   }
   return {
     ...b,
+    orchestrated: b.orchestrated
+      ? validateOrchestrated(b.orchestrated)
+      : undefined,
     chat: b.chat ? validateChat(b.chat) : undefined,
     name: b.name.slice(0, 200),
     from: String(b.from || "another machine")
@@ -140,10 +208,11 @@ export function validateBundle(b: TaskBundle): TaskBundle {
 
 export function arrivalNote(
   b: { from: string; branch: string },
-  cwd: string
+  cwd: string,
+  here: string
 ): string {
   return [
-    `This task just moved here from ${b.from}. Your worktree is now ${cwd}, on branch ${b.branch}.`,
+    `This task just moved from ${b.from} to ${here}. It now runs on ${here}: every command you run executes there, not on ${b.from}, so name ${here} when you report where something ran. Your worktree is now ${cwd}, on branch ${b.branch}.`,
     `Anything that was uncommitted came over as a commit starting "wip: moving to"; fold it into your own commits as you see fit.`,
     `Continue the task where you left off.`,
   ].join(" ");

package/lib/tasks/move-carry.ts

@@ -0,0 +1,102 @@
+/**
+ * An orchestrator's state about a task is keyed by the task's session id, and
+ * a move gives the task a new one on each machine. Carrying re-keys that state
+ * from the old id to the new, inside the transaction that makes the new row,
+ * so the gates, failure counts, asks, scope changes and events judge the task
+ * the same after a move. move-carry.test.ts fails on any table that keys by a
+ * session and is in neither list, so a new one gets decided.
+ */
+
+import type Database from "better-sqlite3";
+import { db } from "../db";
+
+// table, column, and how the id sits in it: the whole value, `task:<id>`, or
+// the tail of a `<condition>:<id>` key.
+export const REKEYED = [
+  ["orchestrator_starts", "target", "id"],
+  ["orchestrator_checks", "session_id", "id"],
+  ["orchestrator_gate_failures", "session_id", "id"],
+  ["orchestrator_gate_failure_commits", "session_id", "id"],
+  ["orchestrator_asks", "subject", "task"],
+  ["brief_amendments", "session_id", "id"],
+  ["task_pr_wakes", "session_id", "id"],
+  ["orchestrator_events", "subject", "id"],
+  ["orchestrator_events", "key", "tail"],
+  ["check_runs", "session_id", "id"],
+  ["away_actions", "subject", "task"],
+  ["task_queue", "after_task", "id"],
+] as const;
+
+// Session-keyed columns that stay on the old id, and why.
+export const KEPT = [
+  ["orchestrator_event_log", "subject", "history is never rewritten"],
+  ["stack_items", "session_id", "stacked tasks don't move"],
+  [
+    "task_queue",
+    "after_any",
+    "a JSON list; a queued task waits on any of them",
+  ],
+] as const;
+
+// Copied onto the new row where it has no value.
+export const CARRIED_COLUMNS = [
+  "started_by",
+  "plan_decided",
+  "plan_reason",
+  "plan_phase",
+  "model_provider",
+  "model_overrides",
+  "merge_armed_at",
+  "merge_armed_seen",
+  "rebased_from",
+  "rebased_to",
+  "rebase_asked_head",
+  "pr_wake_since",
+  "pr_url",
+  "pr_number",
+  "pr_status",
+] as const;
+
+/** The orchestration columns that make a session "an orchestrator's task". */
+export const orchestrationOf = (session: Record<string, unknown>) =>
+  Object.fromEntries(
+    CARRIED_COLUMNS.map((c) => [c, session[c] ?? null] as const)
+  );
+
+export function carryTaskState(
+  fromId: string,
+  toId: string,
+  handle: Database.Database = db
+): void {
+  if (fromId === toId) return;
+  for (const [table, col, shape] of REKEYED) {
+    if (shape === "id")
+      handle
+        .prepare(`UPDATE ${table} SET ${col} = ? WHERE ${col} = ?`)
+        .run(toId, fromId);
+    else if (shape === "task")
+      handle
+        .prepare(`UPDATE ${table} SET ${col} = ? WHERE ${col} = ?`)
+        .run(`task:${toId}`, `task:${fromId}`);
+    else
+      handle
+        .prepare(
+          `UPDATE OR IGNORE ${table}
+             SET ${col} = substr(${col}, 1, length(${col}) - ?) || ?
+             WHERE ${col} LIKE ?`
+        )
+        .run(fromId.length, toId, `%:${fromId}`);
+  }
+  const from = handle
+    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .get(fromId) as Record<string, unknown> | undefined;
+  if (!from) return;
+  const sets = [...CARRIED_COLUMNS, "task_since"]
+    .map((c) => `${c} = COALESCE(${c}, @${c})`)
+    .join(", ");
+  handle.prepare(`UPDATE sessions SET ${sets} WHERE id = @id`).run({
+    ...orchestrationOf(from),
+    task_since: (from.task_since as string | null) ?? from.created_at ?? null,
+    id: toId,
+  });
+}

package/lib/tasks/move-flow.ts

@@ -10,8 +10,11 @@ import { db, type Session } from "../db";
 import { isRemoteHost } from "../hosts";
 import { requireHostLink, type HostLink } from "../hosts/remote-api";
 import { getTaskSession } from "./session";
-import { exportOrResume, markMoved, resumeTask, type TaskBundle } from "./move";
-import { moveRefusal } from "./move-guard";
+import { exportOrResume, resumeTask, type TaskBundle } from "./move";
+import { isOrchestrated, moveRefusal } from "./move-guard";
+import { holderRefusal } from "./held";
+import { isPaused } from "../orchestrator/pause";
+import { sessionWorkspace } from "../models/resolve";
 import { arrived as arrivedHere, importTask } from "./import";
 import {
   forgetHostTasks,
@@ -34,7 +37,8 @@ const LIVE = new Set(["running", "moving"]);
 const g = globalThis as unknown as { __agentosMovesInFlight?: Set<string> };
 const inFlight = (g.__agentosMovesInFlight ??= new Set());
 
-export async function moveTask(id: string, toHostId: string): Promise<Session> {
+/** Why this task can't move to that machine now, as an error; or nothing. */
+export function assertMovable(id: string, toHostId: string): Session {
   const session = getTaskSession(id);
   if (!LIVE.has(session.task_status ?? ""))
     throw new Error(`Task is already ${session.task_status}`);
@@ -47,9 +51,22 @@ export async function moveTask(id: string, toHostId: string): Promise<Session> {
         : "It's already on this machine"
     );
   }
+  // A person here can't move what another machine's orchestrator holds.
+  const held = holderRefusal(session, null);
+  if (held) throw new Error(held);
   const refusal = moveRefusal(session);
   if (refusal) throw new Error(refusal);
+  // Pause stops the orchestrator's new work, and a move is some.
+  const workspace = sessionWorkspace(session);
+  if (workspace && isOrchestrated(session) && isPaused(workspace))
+    throw new Error("The orchestrator is paused; moves wait for Resume");
   if (inFlight.has(id)) throw new Error("It's already moving");
+  return session;
+}
+
+export async function moveTask(id: string, toHostId: string): Promise<Session> {
+  const session = assertMovable(id, toHostId);
+  const toRemote = isRemoteHost(toHostId);
   inFlight.add(id);
   try {
     const moved = toRemote
@@ -66,19 +83,27 @@ export async function moveTask(id: string, toHostId: string): Promise<Session> {
 }
 
 // A machine on an older AgentOS would take a chat task as a terminal one,
-// or refuse to hand one over.
-async function requireChatMoves(link: HostLink): Promise<void> {
+// or an orchestrator's task as a plain one that anyone there could merge, or
+// refuse to hand one over.
+async function requireCapability(
+  link: HostLink,
+  capability: string,
+  what: string
+): Promise<void> {
   const { capabilities = [] } = await hostTasks(link, true).catch((err) => {
     throw new Error(
-      `Can't ask ${link.hostName} whether it takes chat tasks: ${(err as Error).message}`
+      `Can't ask ${link.hostName} whether it takes ${what}: ${(err as Error).message}`
     );
   });
-  if (!capabilities.includes("chat-move"))
+  if (!capabilities.includes(capability))
     throw new Error(
-      `${link.hostName}'s AgentOS can't move chat tasks yet; update it first`
+      `${link.hostName}'s AgentOS can't move ${what} yet; update it first`
     );
 }
 
+const requireChatMoves = (link: HostLink) =>
+  requireCapability(link, "chat-move", "chat tasks");
+
 const unconfirmed = (where: string, err: unknown) =>
   new Error(
     `Couldn't confirm the move with ${where} (${(err as Error).message}). It's paused as "moving": press Move again to finish it.`
@@ -88,6 +113,8 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
   const link = requireHostLink(hostId);
   const chat = session.view === "chat";
   if (chat) await requireChatMoves(link);
+  if (isOrchestrated(session))
+    await requireCapability(link, "orchestrated-move", "orchestrator tasks");
   startProgress(
     session.id,
     link.hostName,
@@ -119,6 +146,13 @@ async function moveOut(session: Session, hostId: string): Promise<Session> {
   return settleMovedOut(session, hostId, link.hostName, there);
 }
 
+function mirrorRunning(id: string): void {
+  db.prepare(
+    `UPDATE sessions SET task_status = 'running', moved_to = NULL
+       WHERE id = ? AND task_status = 'moving'`
+  ).run(id);
+}
+
 async function moveIn(mirror: Session): Promise<Session> {
   const link = requireHostLink(mirror.host_id);
   if (mirror.view === "chat") await requireChatMoves(link);
@@ -127,6 +161,12 @@ async function moveIn(mirror: Session): Promise<Session> {
   // A retry after it arrived here but that machine didn't hear: tidy up.
   let here = arrivedHere(mirror.id);
   if (!here) {
+    // Moving, so nothing reads the mirror as a task to judge, or sign off,
+    // while it leaves (a refusal below puts it back).
+    db.prepare(
+      `UPDATE sessions SET task_status = 'moving', moved_to = 'this machine'
+         WHERE id = ? AND task_status = 'running'`
+    ).run(mirror.id);
     // That machine resumes the agent itself if its half fails there.
     stepProgress(mirror.id, "export");
     let bundle: TaskBundle;
@@ -138,6 +178,7 @@ async function moveIn(mirror: Session): Promise<Session> {
         300000
       ));
     } catch (err) {
+      mirrorRunning(mirror.id);
       if (unknownOutcome(err)) throw unconfirmed(link.hostName, err);
       throw err;
     }
@@ -149,6 +190,7 @@ async function moveIn(mirror: Session): Promise<Session> {
           `${(err as Error).message}; and ${link.hostName} didn't resume it: ${e.message}`
         );
       });
+      mirrorRunning(mirror.id);
       throw err;
     }
   }
@@ -163,7 +205,11 @@ async function moveIn(mirror: Session): Promise<Session> {
       `It's running here now, but ${link.hostName} didn't confirm (${(err as Error).message}). Press Move here again to tidy up.`
     );
   }
-  markMoved(mirror.id, os.hostname());
+  // The mirror was only how this machine showed it: the task is the new row.
+  db.prepare(`DELETE FROM sessions WHERE id = ? AND host_id = ?`).run(
+    mirror.id,
+    mirror.host_id
+  );
   forgetHostTasks(link.hostId);
   return db
     .prepare(`SELECT * FROM sessions WHERE id = ?`)

package/lib/tasks/move-guard.ts

@@ -1,13 +1,24 @@
 /**
  * Tasks that can't move: one waiting on a person (an escalated gate or an
- * open ask), on a LumifyHub card, in a stack, or started by an orchestrator
- * (its brakes, ceiling and Pause count only what runs here). Their guard state is keyed
- * by this session and wouldn't follow it, so the other machine could merge
- * what's waiting on them.
+ * open ask), on a LumifyHub card, or in a stack. A task an orchestrator
+ * started does move: its state is re-keyed to the new session (move-carry),
+ * and the machine it lands on holds it for that orchestrator's device
+ * (held.ts), so nothing there merges it.
  */
 
 import { db, type Session } from "../db";
 import { escalations } from "../orchestrator/gates";
+import { taskSubject } from "../orchestrator/asks";
+
+/** Started by an orchestrator, or held for one by the machine it left. */
+export function isOrchestrated(session: Session): boolean {
+  if (session.started_by || session.held_by_device) return true;
+  return !!db
+    .prepare(
+      `SELECT 1 FROM orchestrator_starts WHERE kind != 'stack' AND target = ? LIMIT 1`
+    )
+    .get(session.id);
+}
 
 export function moveRefusal(session: Session): string | null {
   if (session.quick_of)
@@ -16,9 +27,9 @@ export function moveRefusal(session: Session): string | null {
     return "It's waiting on you (an escalated gate), so it stays here";
   const ask = db
     .prepare(
-      `SELECT 1 FROM orchestrator_asks WHERE subject = ? AND status = 'open' LIMIT 1`
+      `SELECT 1 FROM orchestrator_asks WHERE subject IN (?, ?) AND status = 'open' LIMIT 1`
     )
-    .get(session.id);
+    .get(session.id, taskSubject(session.id));
   if (ask) return "It has an open ask waiting on you, so it stays here";
   const row = db
     .prepare(
@@ -31,12 +42,5 @@ export function moveRefusal(session: Session): string | null {
     | undefined;
   if (row?.lh_card_id) return "Card tasks run on this machine only for now";
   if (row?.stacked) return "Stacked tasks run on this machine only for now";
-  const orchestrated = db
-    .prepare(
-      `SELECT 1 FROM orchestrator_starts WHERE kind != 'stack' AND target = ? LIMIT 1`
-    )
-    .get(session.id);
-  if (orchestrated)
-    return "An orchestrator's tasks run on this machine only for now";
   return null;
 }

package/lib/tasks/move-recover.ts

@@ -12,6 +12,7 @@ import { hostApi, hostLink, type HostLink } from "../hosts/remote-api";
 import { getTaskSession } from "./session";
 import { markMoved, resumeTask } from "./move";
 import { forgetHostTasks, mirrorTask, unknownOutcome } from "./remote";
+import { carryTaskState } from "./move-carry";
 
 /** POST, repeated when the outcome is unknown (the calls are idempotent). */
 export async function tell(
@@ -50,6 +51,7 @@ export function settleMovedOut(
   db.transaction(() => {
     markMoved(session.id, hostName);
     mirrorTask(hostId, session.project_id, there);
+    carryTaskState(session.id, there.id);
   })();
   forgetHostTasks(hostId);
   return db

package/lib/tasks/move.ts

@@ -6,18 +6,26 @@
  * it off and a second move of it is refused.
  */
 
+import fs from "fs";
 import os from "os";
+import path from "path";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { endTmuxSession } from "../tmux/end";
 import { launchClaude } from "../agents/launch";
 import { buildTaskBrief } from "./brief";
 import { git as runGit } from "../git-exec";
-import { getTaskSession } from "./session";
+import { getTaskSession, isoUTC } from "./session";
 import { projectRef } from "./project-ref";
-import { moveRefusal } from "./move-guard";
-import { MAX_TRANSCRIPT_BYTES, type TaskBundle } from "./move-bundle";
+import { isOrchestrated, moveRefusal } from "./move-guard";
+import {
+  MAX_PLAN_BYTES,
+  MAX_TRANSCRIPT_BYTES,
+  type OrchestratedBundle,
+  type TaskBundle,
+} from "./move-bundle";
 import { stepProgress } from "./move-progress";
+import { PLAN_FILE } from "../models/plan-step";
 import { dropSessionDatabase } from "../project-config/database";
 import { releaseChat } from "../chat/runner";
 import { collectWhileMoving } from "../chat/hold";
@@ -98,6 +106,43 @@ function claimMoving(id: string, to: string): { fresh: boolean } {
 // Set by exportTask: did this call stop a running agent, or retry a move?
 const freshClaims = new Set<string>();
 
+const readPlanFile = (cwd: string): string | null => {
+  try {
+    const text = fs.readFileSync(path.join(cwd, PLAN_FILE), "utf8");
+    return text.length > MAX_PLAN_BYTES ? null : text;
+  } catch {
+    return null;
+  }
+};
+
+// The orchestrator that holds the task: its own, or the one on the machine
+// that moved it here.
+function orchestratorOf(
+  session: Session
+): { id: string; name: string } | undefined {
+  if (session.held_for && session.held_for_name)
+    return { id: session.held_for, name: session.held_for_name };
+  if (!session.started_by) return undefined;
+  const o = db
+    .prepare(`SELECT name FROM sessions WHERE id = ?`)
+    .get(session.started_by) as { name: string } | undefined;
+  return o ? { id: session.started_by, name: o.name } : undefined;
+}
+
+// What an orchestrator's task carries besides its work (the orchestrator's
+// own state is re-keyed here; see move-carry).
+function orchestratedBundle(session: Session): OrchestratedBundle {
+  return {
+    heldFrom: session.held_from || os.hostname(),
+    since: isoUTC(session.task_since ?? session.created_at),
+    modelProvider: session.model_provider ?? null,
+    modelOverrides: session.model_overrides ?? null,
+    planPhase: session.plan_phase ?? null,
+    planFile: readPlanFile(session.working_directory),
+    orchestrator: orchestratorOf(session),
+  };
+}
+
 /**
  * Stops the agent and pushes everything. On failure the task stays moving;
  * the caller resumes it (exportOrResume) when it knows nothing arrived.
@@ -163,6 +208,7 @@ export async function exportTask(id: string, to: string): Promise<TaskBundle> {
           ? { sessionId: claudeId, cwd, home: os.homedir(), transcript }
           : null,
       chat: chatBundle,
+      orchestrated: isOrchestrated(now) ? orchestratedBundle(now) : undefined,
     };
   } finally {
     packed();

package/lib/tasks/moved-away.ts

@@ -0,0 +1,37 @@
+/**
+ * What a machine tidies up after a task it held went back to the machine
+ * that sent it: its agent and chat worker stop, its ports are released, and
+ * its worktree goes when nothing in it would be lost (no uncommitted change,
+ * no commit a remote lacks). The row stays, archived, as history.
+ */
+
+import { db, type Session } from "../db";
+import { endSessionAgent } from "../sessions/end";
+import { releasePorts } from "../ports";
+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
+    | Session
+    | undefined;
+  if (!s || s.task_status !== "moved" || !s.held_by_device)
+    return { action: "none" };
+  await endSessionAgent(s).catch((err) =>
+    console.error(`[moved-away] ${id}: agent not stopped:`, err)
+  );
+  releasePorts(id);
+  const fate = await settleWorktree(s, null, true).catch(
+    (err): WorktreeFate => ({
+      action: "kept",
+      why: `it couldn't be checked: ${err instanceof Error ? err.message : err}`,
+      path: s.worktree_path ?? "",
+    })
+  );
+  archiveSession(id);
+  if (fate.action === "kept")
+    console.warn(
+      `[moved-away] ${id}: worktree kept at ${fate.path}: ${fate.why}`
+    );
+  return fate;
+}

package/lib/tasks/remote.ts

@@ -27,6 +27,12 @@ export const TASK_CAPABILITIES = [
   "chat-turn",
   "keyed-start",
   "chat-move",
+  // Holds an orchestrator's task for the machine that sent it, and answers
+  // its messages, reads, stops and done (lib/tasks/held.ts).
+  "orchestrated-move",
+  // A held task's chat facts and its messages for its orchestrator.
+  "held-chat-facts",
+  "held-replies",
 ] as const;
 
 export interface HostTasks {

package/lib/tasks/session.ts

@@ -170,7 +170,7 @@ export async function prFor(
   const branch = renamed ?? session.branch_name;
   if (!branch) return null;
   // A PR older than the task is an earlier use of the branch's name.
-  const since = isoUTC(session.created_at);
+  const since = isoUTC(session.task_since ?? session.created_at);
   let pr: TaskPR | null;
   if (renamed) {
     // Follow a rename only on gh's answer: a failure leaves the row put.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.517",
+  "version": "0.3.519",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"