@saadnvd1/agent-os 0.3.517 → 0.3.519

package/lib/db/migrations.ts

@@ -1689,6 +1689,56 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 73,
+    name: "orchestrated_task_moves",
+    up: (db) => {
+      // task_since: when the task first started, kept across moves (null:
+      // created_at). held_by_device / held_from: the device and machine of
+      // the orchestrator that moved this task here; only that device may
+      // merge, arm, message or move it. plan_note: the "plan written" line
+      // of a held task, for its orchestrator to read.
+      const add = (col: string) => {
+        const columns = db.prepare(`PRAGMA table_info(sessions)`).all() as {
+          name: string;
+        }[];
+        if (!columns.some((c) => c.name === col))
+          db.exec(`ALTER TABLE sessions ADD COLUMN ${col} TEXT`);
+      };
+      for (const col of [
+        "task_since",
+        "held_by_device",
+        "held_from",
+        "plan_note",
+      ])
+        add(col);
+    },
+  },
+  {
+    id: 74,
+    name: "held_task_replies",
+    up: (db) => {
+      // held_for / held_for_name: the orchestrator (id, name there) a held
+      // task messages. relay_state: a held task's message to it, waiting for
+      // the holder to pull it (pending) or pulled (relayed). relay_key: a
+      // pulled message's key on the orchestrator's machine, so a repeat pull
+      // is not delivered twice.
+      const has = (table: string, col: string) =>
+        (
+          db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[]
+        ).some((c) => c.name === col);
+      for (const col of ["held_for", "held_for_name"])
+        if (!has("sessions", col))
+          db.exec(`ALTER TABLE sessions ADD COLUMN ${col} TEXT`);
+      for (const col of ["relay_state", "relay_key"])
+        if (!has("bus_messages", col))
+          db.exec(`ALTER TABLE bus_messages ADD COLUMN ${col} TEXT`);
+      db.exec(
+        `CREATE UNIQUE INDEX IF NOT EXISTS idx_bus_relay_key ON bus_messages(relay_key) WHERE relay_key IS NOT NULL;
+         CREATE INDEX IF NOT EXISTS idx_bus_relay_pending ON bus_messages(relay_state) WHERE relay_state = 'pending'`
+      );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -119,6 +119,15 @@ export interface Session {
   rebase_asked_head?: string | null;
   // When its PR's reviews and comments started being watched (pr-wake.ts).
   pr_wake_since?: string | null;
+  // When the task first started, kept across moves (null: created_at).
+  task_since?: string | null;
+  // The device and machine of the orchestrator that moved this task here.
+  held_by_device?: string | null;
+  held_from?: string | null;
+  held_for?: string | null;
+  held_for_name?: string | null;
+  // A held task's "plan written" line, for its orchestrator to read.
+  plan_note?: string | null;
   // Orchestration fields
   conductor_session_id: string | null;
   worker_task: string | null;

package/lib/done/bulk.ts

@@ -54,6 +54,8 @@ function scopeSessions(scope: DoneScope): Session[] {
          AND role IS NULL AND archived_at IS NULL
          -- A linked machine's own sessions are cleaned up there.
          AND peer_mirror = 0
+         -- A task another machine's orchestrator moved here is its to finish.
+         AND held_by_device IS NULL
          AND (task_status IS NULL OR task_status = 'running')
        ORDER BY created_at`
     )
@@ -75,6 +77,12 @@ export async function idleSessions(
 
 // The caller's workspace when its project has one, else its project.
 export function scopeOf(session: Session): DoneScope {
+  // An orchestrator acts through its tools, which Pause holds and which are
+  // logged; aos would reach the same sessions past both.
+  if (session.role === "orchestrator")
+    throw new Error(
+      `${session.name} is an orchestrator: it moves, finishes and stops sessions with its move, done and stop tools, not aos`
+    );
   const project = session.project_id ? getProject(session.project_id) : null;
   if (!project || project.is_uncategorized)
     throw new Error(`${session.name} isn't in a project`);

package/lib/done/index.ts

@@ -25,6 +25,8 @@ import { sessionMergePolicy } from "../tasks/finish";
 import { releasePorts } from "../ports";
 import { dropSessionDatabase } from "../project-config/database";
 import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
+import { hostLink } from "../hosts/remote-api";
+import { doneHeldTask } from "../tasks/held-remote";
 import { captureMergedTask } from "../session-logs";
 import { pushMerged } from "../notify/push/events";
 
@@ -161,6 +163,19 @@ export async function doneSession(
     await stopAgent(s);
     // The sign-off's cleanup has already settled it; this reads the result.
     worktree = await settleWorktree(s, { prHead: m.sha });
+  } else if (s.started_by && s.task_prompt && hostLink(s.host_id)) {
+    // Moved to a linked machine by its orchestrator: that machine stops the
+    // agent and removes the worktree, which is where they are.
+    await doneHeldTask(s);
+    if (plan.mark) mark(s, plan.mark, plan.pr);
+    else
+      db.prepare(
+        `UPDATE sessions SET task_status = 'done' WHERE id = ? AND task_status = 'running'`
+      ).run(s.id);
+    worktree = {
+      action: "removed",
+      why: `on ${hostLink(s.host_id)?.hostName ?? "its machine"}`,
+    };
   } else {
     if (plan.mark) mark(s, plan.mark, plan.pr);
     if (

package/lib/done/worktree.ts

@@ -114,14 +114,15 @@ const gone = (merged: MergedAs | null, still = false) => ({
 export async function worktreeFate(
   session: Judged,
   merged: MergedAs | null,
-  waitMs = 60_000
+  waitMs = 60_000,
+  movedAway = false
 ): Promise<FatePreview> {
   const path = session.worktree_path;
   if (!path) return { action: "none" };
   for (;;) {
     if (!(await removalSettled(path, waitMs))) return gone(merged, true);
     if (!fs.existsSync(path)) return gone(merged);
-    const fate = await judge(session, merged);
+    const fate = await judge(session, merged, movedAway);
     // A removal that started while it read: read what it leaves.
     if (!removalRunning(path) && fs.existsSync(path)) return fate;
   }
@@ -133,8 +134,17 @@ async function commitsKeep(
   path: string,
   repo: string,
   session: Judged,
-  merged: MergedAs | null
+  merged: MergedAs | null,
+  movedAway = false
 ): Promise<string | null> {
+  // The task went on elsewhere: only commits no remote has would be lost.
+  if (movedAway) {
+    const stray = await strayCommits(path, {}).catch(() => null);
+    if (stray === null) return "its commits can't be checked";
+    return stray > 0
+      ? `${stray} commit${stray === 1 ? " is" : "s are"} on it that no remote has`
+      : null;
+  }
   if (merged) {
     const stray = await strayCommits(path, merged).catch(() => null);
     if (stray === null) return "its commits can't be checked";
@@ -163,7 +173,8 @@ async function commitsKeep(
 // kept one names every reason, the commits as well as the changes.
 async function judge(
   session: Judged,
-  merged: MergedAs | null
+  merged: MergedAs | null,
+  movedAway = false
 ): Promise<FatePreview> {
   const path = session.worktree_path!;
   const keep = (why: string) => ({ action: "kept" as const, why, path });
@@ -183,14 +194,16 @@ async function judge(
     unsaved.length
       ? `it has uncommitted changes (${describeChanges(unsaved)})`
       : null,
-    await commitsKeep(path, repo, session, merged),
+    await commitsKeep(path, repo, session, merged, movedAway),
   ].filter((w) => w !== null);
   if (why.length) return keep(why.join(", and "));
   return {
     action: "remove",
-    why: merged
-      ? "its branch is merged"
-      : "its branch has no commits of its own",
+    why: movedAway
+      ? "its work moved to another machine"
+      : merged
+        ? "its branch is merged"
+        : "its branch has no commits of its own",
     repo,
   };
 }
@@ -199,9 +212,10 @@ async function judge(
 // and says so only once it's really gone.
 export async function settleWorktree(
   session: Judged,
-  merged: MergedAs | null
+  merged: MergedAs | null,
+  movedAway = false
 ): Promise<WorktreeFate> {
-  const fate = await worktreeFate(session, merged);
+  const fate = await worktreeFate(session, merged, undefined, movedAway);
   if (fate.action !== "remove") return fate;
   const path = session.worktree_path!;
   await deleteWorktree(path, fate.repo, true).catch(() => {});

package/lib/hosts/remote-api.ts

@@ -70,6 +70,18 @@ export const cleanRemoteText = (s: unknown): string =>
     .trim()
     .slice(0, 300);
 
+/**
+ * Another machine's multi-line text (a chat's tail): control characters
+ * other than newline and tab become spaces, and the end is kept within `cap`.
+ */
+export const cleanRemoteBlock = (s: unknown, cap: number): string => {
+  const text = String(s ?? "")
+    .replace(/\r\n?/g, "\n")
+    .replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, " ")
+    .replace(/\s+$/, "");
+  return text.length > cap ? `…${text.slice(text.length - cap + 1)}` : text;
+};
+
 /**
  * Why a call failed. `refused`: that AgentOS answered and said no, so nothing
  * happened there. Otherwise the outcome is unknown (unreachable, timed out,

package/lib/models/plan-step.ts

@@ -73,9 +73,12 @@ export function planSummary(text: string, max = 5): string[] {
 
 // Tells the orchestrator that started a task its plan is written, once.
 function announcePlan(s: Session, ref: string): void {
-  if (!s.started_by) return;
+  if (!s.started_by && !s.held_by_device) return;
   const workspaceId = sessionWorkspace(s);
-  if (!workspaceId || !s.worktree_path) return;
+  // A task held for another machine's orchestrator can't reach it: the line
+  // waits on the task for that orchestrator to read (orchestrator/facts).
+  if (!s.held_by_device && !workspaceId) return;
+  if (!s.worktree_path) return;
   const file = path.join(s.worktree_path, PLAN_FILE);
   let head = `Task "${s.name}": no plan file was written; implementing on ${ref} anyway.`;
   try {
@@ -85,7 +88,14 @@ function announcePlan(s: Session, ref: string): void {
   } catch {
     // No plan file: the line says so.
   }
-  queueEvent(workspaceId, `plan-done:${s.id}`, s.id, head);
+  if (s.held_by_device) {
+    db.prepare(`UPDATE sessions SET plan_note = ? WHERE id = ?`).run(
+      head,
+      s.id
+    );
+    return;
+  }
+  queueEvent(workspaceId!, `plan-done:${s.id}`, s.id, head);
 }
 
 export const implementMessageId = (sessionId: string) =>

package/lib/orchestrator/act.ts

@@ -19,7 +19,9 @@ import {
   launchSession,
   type StartView,
 } from "../sessions/launch";
-import { createTask, dropTask } from "../tasks";
+import { assertMovable, createTask, dropTask, moveTask } from "../tasks";
+import { getHost, hostIdNamed } from "../hosts";
+import { queueEvent } from "./events";
 import {
   findQueued,
   queuedLabel,
@@ -280,3 +282,41 @@ export async function done(workspaceId: string, ref: string): Promise<string> {
 export async function stop(workspaceId: string, ref: string): Promise<string> {
   return stopSession(findWorkspaceSession(workspaceId, ref));
 }
+
+// Carries a task to a linked machine, or back ("here"): heavy test or build
+// work can run on the box. The move takes minutes, so it runs in the
+// background; the orchestrator is told when the task lands or doesn't.
+// Everything about the task (gates, events, read/send/stop/drop) is the same
+// wherever it runs; the machine it lands on holds it for this one.
+export async function moveTaskTo(
+  workspaceId: string,
+  ref: string,
+  machine: string
+): Promise<string> {
+  const task = workspaceTask(workspaceId, ref);
+  const hostId = hostIdNamed(machine);
+  assertMovable(task.id, hostId);
+  const where = hostId === "local" ? "this machine" : machineName(hostId);
+  void moveTask(task.id, hostId).then(
+    (moved) => {
+      addNote(workspaceId, `Moved task ${task.name} to ${where}.`);
+      queueEvent(
+        workspaceId,
+        `move:${moved.id}:${Date.now()}`,
+        moved.id,
+        `Task ${task.name} now runs on ${where}.`
+      );
+    },
+    (error) =>
+      queueEvent(
+        workspaceId,
+        `move-failed:${task.id}:${Date.now()}`,
+        task.id,
+        `Moving task ${task.name} to ${where} failed: ${error instanceof Error ? error.message : String(error)}. It carries on where it was unless it says it's paused as "moving".`
+      )
+  );
+  return `Moving ${task.name} to ${where}. It takes a few minutes; an event tells you when it runs there.`;
+}
+
+const machineName = (hostId: string) =>
+  getHost(hostId)?.name ?? "the other machine";

package/lib/orchestrator/armed.ts

@@ -58,7 +58,8 @@ function armedTasks(workspaceId: string): Session[] {
     .prepare(
       `SELECT s.* FROM sessions s JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.merge_armed_at IS NOT NULL
-         AND s.task_status = 'running' AND s.peer_mirror = 0`
+         AND s.task_status = 'running' AND s.peer_mirror = 0
+         AND s.held_by_device IS NULL`
     )
     .all(workspaceId) as Session[];
 }
@@ -100,6 +101,10 @@ export function armTask(task: Session): void {
     );
   if (task.peer_mirror)
     throw new Error(`${task.name} runs on a linked machine; arm it there`);
+  if (task.held_by_device)
+    throw new Error(
+      `${task.name} is held for ${task.held_from ?? "another machine"}'s orchestrator; it arms it there`
+    );
   if (!armingWorkspace(task))
     throw new Error(
       `${task.name}'s project isn't in a workspace with an orchestrator, which an armed merge reports to`

package/lib/orchestrator/brakes.ts

@@ -74,6 +74,15 @@ export async function runningCount(
             "running";
     if (busy) running.add(s.id);
   }
+  // A task mid-move is out of the list above, but it runs again within
+  // minutes, here or there: it holds its slot.
+  const moving = db
+    .prepare(
+      `SELECT s.id FROM sessions s JOIN projects p ON p.id = s.project_id
+       WHERE p.workspace_id = ? AND s.task_status = 'moving' AND s.peer_mirror = 0`
+    )
+    .all(workspaceId) as { id: string }[];
+  for (const { id } of moving) running.add(id);
   for (const { target } of startsSince(workspaceId, now - WARMUP_MS))
     if (target) running.add(target);
   return running.size;

package/lib/orchestrator/brief.ts

@@ -109,7 +109,8 @@ Acting:
 - \`${TOOL_NAMES.quick_pr}\` (change, title, body): commit everything in a quick change, push its branch (never the default branch) and open its PR, or push to the PR it has; its review starts at once. Then it's gated like any task: CI, that review (also its code-review gate), scope, then sign_off or arm. It's in \`sessions\` as your quick change; drop it to throw it away, and it's cleaned up like a task when it merges or is dropped.
 - \`${TOOL_NAMES.stack}\` (target, plan_only?): run a board's open cards as stacked tasks; plan_only shows the plan without starting.
 - \`${TOOL_NAMES.land}\` (id): merge a stack bottom-up through the gates.
-- \`${TOOL_NAMES.drop}\` (task, reason): close a task's PR and remove its worktree.
+- \`${TOOL_NAMES.move}\` (task, machine): carry a running task to a linked machine (heavy test or build work), or back with machine "here". It keeps its branch, conversation and plan, and everything you do with a task works the same there: its events come to you, read, send, stop, done and drop reach it, and the gates judge its PR at its head. The machine it lands on holds it for you and can't merge it. It runs in the background; an event says when it lands. Refused while paused, and for a task waiting on Saad.
+- \`${TOOL_NAMES.drop}\` (task, reason): close a task's PR and remove its worktree (on whichever machine holds it).
 - \`${TOOL_NAMES.stop}\` (session): stop a session's agent, keeping its work.
 - \`${TOOL_NAMES.done}\` (session): finish a session whose work is complete. A task with an open PR merges through the same gates as sign_off first (refused naming the gate otherwise); then the agent stops, the worktree goes only if nothing in it would be lost, and the session is archived out of view. Not a rejection: use drop for that.
 - \`${TOOL_NAMES.add_project}\` (path, name?): make a git repository on this machine a project of this workspace, or move the project already at that path in when it's in no workspace. Use it rather than sending Saad steps. It refuses a folder that isn't a git repository or holds secrets, and a project another workspace has: moving that is Saad's call, so ask_saad.

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)