@saadnvd1/agent-os 0.3.597 → 0.3.601

package/lib/plans/claim.ts

@@ -0,0 +1,131 @@
+// A task that builds a waiting piece of a plan claims it, so the release
+// sweep never starts that piece a second time.
+
+import { db } from "../db";
+import { getProject } from "../projects";
+import type { FeaturePiece } from "./features";
+
+export interface WaitingPiece extends FeaturePiece {
+  feature_name: string;
+}
+
+const COLUMNS = `fp.*, f.name AS feature_name`;
+
+// Waiting pieces in `projectId` of the plans the caller belongs to: the plan
+// it wrote, or the one whose piece it is building.
+export function waitingPiecesFor(
+  callerId: string,
+  projectId: string
+): WaitingPiece[] {
+  return db
+    .prepare(
+      `SELECT ${COLUMNS} FROM feature_pieces fp JOIN features f ON f.id = fp.feature_id
+       WHERE f.status = 'building' AND fp.status = 'waiting' AND fp.project_id = ?
+         AND (f.plan_session_id = ?
+              OR EXISTS (SELECT 1 FROM feature_pieces o
+                         WHERE o.feature_id = f.id AND o.session_id = ?))
+       ORDER BY f.created_at, fp.position`
+    )
+    .all(projectId, callerId, callerId) as WaitingPiece[];
+}
+
+// The orchestrator's view: waiting pieces of its workspace's plans.
+export function workspacePieces(
+  workspaceId: string,
+  projectId: string
+): WaitingPiece[] {
+  return db
+    .prepare(
+      `SELECT ${COLUMNS} FROM feature_pieces fp JOIN features f ON f.id = fp.feature_id
+       WHERE f.status = 'building' AND fp.status = 'waiting' AND fp.project_id = ?
+         AND f.workspace_id = ?
+       ORDER BY f.created_at, fp.position`
+    )
+    .all(projectId, workspaceId) as WaitingPiece[];
+}
+
+export const listPieces = (waiting: WaitingPiece[]) =>
+  waiting.map((p) => `${p.position} ${p.name}`).join(", ");
+
+// `name`, `position`, or `feature/name`; an error that lists what's waiting
+// when nothing, or more than one, matches.
+export function findPiece(waiting: WaitingPiece[], ref: string): WaitingPiece {
+  const want = ref.trim().toLowerCase();
+  const slash = want.indexOf("/");
+  const only = slash > 0 ? want.slice(0, slash) : null;
+  const piece = slash > 0 ? want.slice(slash + 1) : want;
+  const hits = waiting.filter(
+    (p) =>
+      (!only || p.feature_name.toLowerCase() === only) &&
+      (p.name.toLowerCase() === piece || String(p.position) === piece)
+  );
+  if (hits.length === 1) return hits[0];
+  const names = waiting
+    .map((p) =>
+      waiting.some((o) => o.feature_id !== p.feature_id)
+        ? `${p.feature_name}/${p.name}`
+        : `${p.position} ${p.name}`
+    )
+    .join(", ");
+  if (hits.length > 1)
+    throw new Error(
+      `"${ref}" matches more than one waiting piece: ${names}. Name it as feature/piece.`
+    );
+  throw new Error(
+    waiting.length
+      ? `No waiting piece "${ref}". Waiting pieces: ${names}.`
+      : `No waiting piece "${ref}": nothing in your plan is waiting in this project.`
+  );
+}
+
+export function pieceRefusal(
+  waiting: WaitingPiece[],
+  projectId: string
+): string {
+  const where = getProject(projectId)?.name ?? "this project";
+  return `Your plan "${waiting[0].feature_name}" has pieces waiting in ${where}: ${listPieces(waiting)}. Name the one this task builds with --piece <name>; AgentOS starts the others itself when they are due.`;
+}
+
+export function pieceStatus(id: number): string | undefined {
+  return (
+    db.prepare(`SELECT status FROM feature_pieces WHERE id = ?`).get(id) as
+      | { status: string }
+      | undefined
+  )?.status;
+}
+
+export function claimable(id: number): void {
+  const status = pieceStatus(id);
+  if (status !== "waiting")
+    throw new Error(`That piece is ${status ?? "gone"}, not waiting`);
+}
+
+// Synchronous, so nothing runs between the check and the write.
+export function claimPiece(id: number, sessionId: string): void {
+  const changed = db
+    .prepare(
+      `UPDATE feature_pieces SET status = 'building', session_id = ?, note = NULL
+       WHERE id = ? AND status = 'waiting'`
+    )
+    .run(sessionId, id).changes;
+  if (!changed)
+    throw new Error(`That piece is ${pieceStatus(id) ?? "gone"}, not waiting`);
+}
+
+// Gives a claim back when the session it was made for never came to be.
+export function releaseClaim(id: number, sessionId: string): void {
+  db.prepare(
+    `UPDATE feature_pieces SET status = 'waiting', session_id = NULL
+     WHERE id = ? AND session_id = ? AND status = 'building'`
+  ).run(id, sessionId);
+}
+
+export function pieceLabel(id: number): string {
+  const r = db
+    .prepare(
+      `SELECT fp.position, fp.name, f.name AS feature FROM feature_pieces fp
+       JOIN features f ON f.id = fp.feature_id WHERE fp.id = ?`
+    )
+    .get(id) as { position: number; name: string; feature: string } | undefined;
+  return r ? `piece ${r.position} ${r.name} of "${r.feature}"` : "a piece";
+}

package/lib/plans/release.ts

@@ -9,7 +9,7 @@ import { createTask } from "../tasks";
 import { startOrQueue } from "../tasks/queue";
 import { braked, BrakeRefused } from "../orchestrator/brakes";
 import { queueEvent, queueEventOnce } from "../orchestrator/events";
-import { amendBrief, amendmentsOf } from "../orchestrator/amendments";
+import { amendBrief, scopeChangesOf } from "../orchestrator/amendments";
 import { usageRows } from "../session-logs/gather";
 import { pieceBrief } from "./pieces";
 import {
@@ -122,6 +122,9 @@ export const realDeps: ReleaseDeps = {
       // A retry under the same id clears what a failed attempt left behind.
       reclaim: true,
       startedBy: plan?.started_by ?? null,
+      parentSessionId: feature.plan_session_id,
+      startedVia: "plan" as const,
+      startedByDevice: plan?.started_by_device ?? null,
       originWorkspaceId: feature.workspace_id,
     };
     // A queued task keeps its queue id as its session id once it starts.
@@ -173,7 +176,7 @@ function creditParentMerge(feature: Feature, all: FeaturePiece[]): void {
     )
   )
     return;
-  if (amendmentsOf(parent.id).length) return;
+  if (scopeChangesOf(parent.id).length) return;
   const covered = all.filter(
     (p) => p.status === "waiting" && p.project_id === parent.project_id
   );

package/lib/recipes/run.ts

@@ -152,6 +152,8 @@ export async function startRun(
           access: "full",
           model: typeof model === "string" ? model : null,
           startedBy,
+          parentSessionId: startedBy,
+          startedVia: byOrchestrator ? "orchestrator" : "recipe",
         }).then((l) => ({ ...l, id: l.session.id }))
       );
       settleStart(run.id, "running", { sessionId: session.id });
@@ -167,6 +169,8 @@ export async function startRun(
         plan: false,
         planReason: "recipe run",
         startedBy,
+        parentSessionId: startedBy,
+        startedVia: byOrchestrator ? "orchestrator" : "recipe",
         originWorkspaceId: byOrchestrator ? ws : undefined,
       },
       () =>
@@ -181,6 +185,8 @@ export async function startRun(
             plan: false,
             planReason: "recipe run",
             startedBy,
+            parentSessionId: startedBy,
+            startedVia: byOrchestrator ? "orchestrator" : "recipe",
           })
         )
     );

package/lib/schedules/start.ts

@@ -37,6 +37,7 @@ async function startTask(
     projectId: projectOf(schedule).id,
     prompt: schedule.prompt,
     name: schedule.name,
+    startedVia: "schedule",
     onCreated: onSession,
   });
   return session.id;

package/lib/sessions/fork.ts

@@ -0,0 +1,10 @@
+// A fork continues its parent's conversation: it has a parent but wasn't
+// started by anyone and isn't a task. A task or session started from another
+// session also records that parent, and is not a fork.
+export const isFork = (s: {
+  parent_session_id?: string | null;
+  started_by?: string | null;
+  started_via?: string | null;
+  task_prompt?: string | null;
+}): boolean =>
+  !!s.parent_session_id && !s.started_by && !s.started_via && !s.task_prompt;

package/lib/sessions/launch.ts

@@ -3,6 +3,7 @@
  * then (for a worktree) the setup in the background, then the first message.
  */
 
+import type { StartVia } from "../tasks/starter";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -74,6 +75,7 @@ export interface LaunchInput {
   // The orchestrator session that starts it: it runs on the implementation
   // role's model (or `model`), not the interactive one's.
   startedBy?: string | null;
+  startedVia?: StartVia;
   groupPath?: string;
   systemPrompt?: string | null;
 }
@@ -277,12 +279,14 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       runOn
     );
   db.prepare(
-    `UPDATE sessions SET view = ?, name_source = ?, setup_status = ?, started_by = ? WHERE id = ?`
+    `UPDATE sessions SET view = ?, name_source = ?, setup_status = ?, started_by = ?,
+       started_via = ? WHERE id = ?`
   ).run(
     view,
     naming.source,
     useWorktree ? "running" : null,
     input.startedBy ?? null,
+    input.startedVia ?? (input.startedBy ? "orchestrator" : null),
     id
   );
   if (interactive) setSessionModel(id, interactive);

package/lib/sidebar/live-status.ts

@@ -4,16 +4,37 @@ import {
   type PrStage,
   type PrStageName,
 } from "../tasks/pr-stage";
+import type { StatusBadge } from "./row-badge";
 
-export type LiveTone = "blue" | "amber" | "red" | "green" | "purple" | "muted";
+export type LiveTone =
+  | "blue"
+  | "amber"
+  | "red"
+  | "green"
+  | "purple"
+  | "primary"
+  | "muted";
 
 export interface LivePart {
   text: string;
   tone: LiveTone;
   // Still moving on its own: the UI shows a spinner.
   busy?: boolean;
+  // A status badge (need, stalled, plan step): drawn as a pill, with an icon
+  // for the plan kinds.
+  badge?: StatusBadge["kind"];
+  tip?: string;
 }
 
+export const BADGE_TONE: Record<StatusBadge["kind"], LiveTone> = {
+  need: "amber",
+  failed: "red",
+  stalled: "amber",
+  starting: "muted",
+  planning: "blue",
+  "plan-ready": "primary",
+};
+
 export const PR_STAGE_TONE: Record<PrStageName, LiveTone> = {
   merged: "purple",
   conflicts: "amber",
@@ -28,14 +49,24 @@ export const PR_STAGE_TONE: Record<PrStageName, LiveTone> = {
 };
 
 // What the row's second line says about the session right now, in order:
-// "Compacting", then "PR CI". Empty when there is nothing to say.
+// "Compacting", then a status badge (Needs you, Stalled, Planning, Plan
+// ready), then "PR CI". Empty when there is nothing to say.
 export function liveParts(input: {
   compacting?: boolean;
   prStage?: PrStage;
+  badge?: StatusBadge | null;
 }): LivePart[] {
   const parts: LivePart[] = [];
   if (input.compacting)
     parts.push({ text: "Compacting", tone: "blue", busy: true });
+  const b = input.badge;
+  if (b)
+    parts.push({
+      text: b.label,
+      tone: BADGE_TONE[b.kind],
+      badge: b.kind,
+      tip: b.tip,
+    });
   const s = input.prStage;
   if (s) {
     const word = PR_STAGE_SHORT[s.stage];

package/lib/sidebar/row-badge.ts

@@ -1,7 +1,7 @@
-// The plan badge a row shows on its right: writing its plan, or a plan
+// The plan badge a row shows: writing its plan, or a plan
 // waiting for approval. A need or a stall says more and wins; finished,
 // snoozed and quick-change rows show none. Client-safe.
-import type { SidebarRow } from "./shelves";
+import { NEED_LABEL, type SidebarRow } from "./shelves";
 
 export type RowKindBadge = {
   kind: "planning" | "plan-ready";
@@ -38,3 +38,27 @@ export function rowKindBadge(
     };
   return null;
 }
+
+// The one status badge a row's second line carries: what it needs from you,
+// stalled, or its plan step. They are mutually exclusive by precedence. The
+// queued rows' Failed/Starting use the same shape.
+export type StatusBadge = {
+  kind: "need" | "failed" | "stalled" | "starting" | RowKindBadge["kind"];
+  label: string;
+  tip?: string;
+};
+
+export function rowStatusBadge(
+  row: Parameters<typeof rowKindBadge>[0] &
+    Pick<SidebarRow, "need"> & { status?: SidebarRow["status"] }
+): StatusBadge | null {
+  if (row.need) {
+    const asks = row.status?.asks ?? 0;
+    return {
+      kind: row.need === "failed" ? "failed" : "need",
+      label: `${NEED_LABEL[row.need]}${asks > 1 ? ` ${asks}` : ""}`,
+    };
+  }
+  if (row.status?.stalled) return { kind: "stalled", label: "Stalled" };
+  return rowKindBadge(row);
+}

package/lib/stacks/start.ts

@@ -119,6 +119,7 @@ export async function startItem(
       prompt: promptFromCard(card),
       name: card.title,
       cardId: card.id,
+      startedVia: "stack",
       base,
       onCreated: (sessionId) =>
         q.updateItem(db, item.id, {

package/lib/tasks/held-remote.ts

@@ -16,6 +16,7 @@ import {
 import type { Delivery } from "../bus/delivery";
 import { wakeLine } from "../bus/format";
 import { orchestratedStart } from "./held";
+import { orchestratorOf } from "./starter";
 
 const path = (id: string, leaf: string) =>
   `/api/tasks/${encodeURIComponent(id)}/${leaf}`;
@@ -23,11 +24,12 @@ const path = (id: string, leaf: string) =>
 /**
  * A task its orchestrator put on a linked machine, whether by moving it or
  * by the queue placing it there: the one test every relayed call goes by.
- * (held-replies.ts reads the same rule in SQL: started_by IS NOT NULL.)
+ * (held-replies.ts reads the same rule in SQL: started_by is an orchestrator.)
  */
 export const isHeldRemote = (
   s: Pick<Session, "started_by" | "task_prompt" | "host_id">
-): boolean => !!s.started_by && !!s.task_prompt && !!hostLink(s.host_id);
+): boolean =>
+  !!s.task_prompt && !!hostLink(s.host_id) && !!orchestratorOf(s.started_by);
 
 type Held = Pick<
   Session,

package/lib/tasks/held-replies.ts

@@ -27,18 +27,21 @@ interface Pulled {
   body: string;
 }
 
+// Held means an orchestrator started it, as isHeldRemote reads it.
+const HELD_BY = `started_by IN (SELECT id FROM sessions WHERE role = 'orchestrator')`;
+
 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')`
+         AND ${HELD_BY} 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
+      `SELECT 1 FROM sessions WHERE host_id = ? AND ${HELD_BY}
          AND task_prompt IS NOT NULL AND task_status IN ('running', 'moving')`
     )
     .get(hostId);

package/lib/tasks/held.ts

@@ -5,6 +5,7 @@
  * a green CI, past the gates its orchestrator judges it by.
  */
 
+import { orchestratorOf } from "./starter";
 import os from "os";
 import { db, type Session } from "../db";
 import type { OrchestratedBundle } from "./move-bundle";
@@ -102,7 +103,7 @@ type Holdable = Pick<
 export function mayHold(s: Holdable, device: string): boolean {
   if (!s.task_prompt || s.task_status !== "running") return false;
   if (s.host_id && s.host_id !== "local") return false;
-  if (s.started_by || s.held_by_device) return false;
+  if (orchestratorOf(s.started_by) || s.held_by_device) return false;
   return (
     s.started_by_device === device || s.started_by_device === UNRECORDED_STARTER
   );

package/lib/tasks/index.ts

@@ -48,7 +48,9 @@ import {
 } from "./state";
 import { expandHome, prFor, storedPR, taskSessions } from "./session";
 import { InProgressError, type OrchestratedBundle } from "./move-bundle";
-import { holdFor, mayHold, recordStarter } from "./held";
+import { holdFor, mayHold } from "./held";
+import { orchestratorOf, recordStart, type StartVia } from "./starter";
+import { claimable, claimPiece, releaseClaim } from "../plans/claim";
 import { nameFor } from "../session-titles";
 import { taskSetupOf, type TaskSetup } from "./setup";
 import { taskPlan } from "./plan-view";
@@ -136,8 +138,13 @@ export async function createTask(opts: {
   planReason?: string | null;
   // Stop after the plan and wait for approval (implies plan).
   planOnly?: boolean;
-  // The orchestrator session that started it (null: a person).
+  // The session that started it (null: a person), the session it came from,
+  // and how: every start says (tasks/starter.ts).
   startedBy?: string | null;
+  parentSessionId?: string | null;
+  startedVia: StartVia;
+  // The waiting plan piece it builds: claimed for this task.
+  pieceId?: number;
   // Started from this LumifyHub card, which the task then moves.
   cardId?: string;
   // Stacked: cut from another task's pushed branch, at this exact commit.
@@ -165,7 +172,7 @@ export async function createTask(opts: {
   // (held.ts): that machine's paired device and its description of the task.
   held?: { device: string; orchestrated: OrchestratedBundle };
   // The paired device that sent this keyed start: the only one that may hold it later.
-  startedByDevice?: string;
+  startedByDevice?: string | null;
 }): Promise<Session> {
   if (opts.id) {
     const existing = queries.getSession(db).get(opts.id) as Session | undefined;
@@ -222,6 +229,7 @@ async function startTask(
   if (!prompt) throw new Error("Describe the task");
   const project = getProject(opts.projectId);
   if (!project || project.is_uncategorized) throw new Error("Pick a project");
+  if (opts.pieceId) claimable(opts.pieceId);
   const hostId = opts.hostId ?? project.host_id;
   const view = opts.view ?? DEFAULT_START_VIEW;
   const agent = opts.agent ?? "claude";
@@ -251,6 +259,16 @@ async function startTask(
       view,
       startedBy: opts.startedBy,
     });
+    // The mirror's started_by stays orchestrator-only: a held-remote task is
+    // relayed, stopped and answered through it. A plain calling task is its
+    // parent and started_via only.
+    recordStart(session.id, {
+      startedBy: orchestratorOf(opts.startedBy),
+      parentSessionId: opts.parentSessionId ?? null,
+      startedVia: opts.startedVia,
+      startedByDevice: opts.held?.device ?? opts.startedByDevice,
+    });
+    if (opts.pieceId) claimPiece(opts.pieceId, session.id);
     opts.onCreated?.(session.id);
     return session;
   }
@@ -295,50 +313,71 @@ async function startTask(
   const model = routing.first.model;
   const tmuxName = `${provider.id}-${id}`;
 
-  queries
-    .createSession(db)
-    .run(
-      id,
-      naming.name,
-      tmuxName,
-      wt.worktreePath,
-      null,
-      model,
-      null,
-      "sessions",
-      agent,
-      1,
-      project.id,
-      "local"
+  // Claimed right before the row exists, with nothing awaited between, so the
+  // release sweep can't start the same piece.
+  if (opts.pieceId) {
+    try {
+      claimPiece(opts.pieceId, id);
+    } catch (error) {
+      await discardLeftoverStart(projectPath, feature).catch(() => {});
+      throw error;
+    }
+  }
+  try {
+    queries
+      .createSession(db)
+      .run(
+        id,
+        naming.name,
+        tmuxName,
+        wt.worktreePath,
+        null,
+        model,
+        null,
+        "sessions",
+        agent,
+        1,
+        project.id,
+        "local"
+      );
+    queries
+      .updateSessionWorktree(db)
+      .run(wt.worktreePath, wt.branchName, baseBranch, null, id);
+    // Everything the launch needs is on the row, so a restart can resume it.
+    db.prepare(
+      `UPDATE sessions SET task_prompt = ?, task_brief = ?, task_status = 'running', setup_status = 'running', name_source = ?, view = ?,
+         model_provider = ?, model_overrides = ?, plan_phase = ?, plan_only = ?,
+         plan_decided = ?, plan_reason = ? WHERE id = ?`
+    ).run(
+      prompt,
+      buildTaskBrief({
+        branch: wt.branchName,
+        baseBranch,
+        stack: opts.base?.stack,
+      }),
+      naming.source,
+      view,
+      routing.first.provider.id === ANTHROPIC
+        ? null
+        : routing.first.provider.id,
+      routing.override ? JSON.stringify(routing.override) : null,
+      routing.plan ? "planning" : null,
+      routing.planOnly ? 1 : null,
+      routing.planOnly ? 1 : opts.plan === undefined ? null : opts.plan ? 1 : 0,
+      opts.planReason?.trim() || null,
+      id
     );
-  queries
-    .updateSessionWorktree(db)
-    .run(wt.worktreePath, wt.branchName, baseBranch, null, id);
-  // Everything the launch needs is on the row, so a restart can resume it.
-  db.prepare(
-    `UPDATE sessions SET task_prompt = ?, task_brief = ?, task_status = 'running', setup_status = 'running', name_source = ?, view = ?,
-       model_provider = ?, model_overrides = ?, plan_phase = ?, plan_only = ?,
-       plan_decided = ?, plan_reason = ?, started_by = ? WHERE id = ?`
-  ).run(
-    prompt,
-    buildTaskBrief({
-      branch: wt.branchName,
-      baseBranch,
-      stack: opts.base?.stack,
-    }),
-    naming.source,
-    view,
-    routing.first.provider.id === ANTHROPIC ? null : routing.first.provider.id,
-    routing.override ? JSON.stringify(routing.override) : null,
-    routing.plan ? "planning" : null,
-    routing.planOnly ? 1 : null,
-    routing.planOnly ? 1 : opts.plan === undefined ? null : opts.plan ? 1 : 0,
-    opts.planReason?.trim() || null,
-    opts.startedBy ?? null,
-    id
-  );
-  const starter = opts.held?.device ?? opts.startedByDevice;
-  if (starter) recordStarter(id, starter);
+    recordStart(id, {
+      startedBy: opts.startedBy ?? null,
+      parentSessionId: opts.parentSessionId ?? null,
+      startedVia: opts.startedVia,
+      startedByDevice: opts.held?.device ?? opts.startedByDevice,
+    });
+  } catch (error) {
+    // The claim was made for a session that never existed.
+    if (opts.pieceId) releaseClaim(opts.pieceId, id);
+    throw error;
+  }
   if (opts.held) holdFor(id, opts.held.device, opts.held.orchestrated);
   opts.onCreated?.(id);
   void naming.refine?.(id);

package/lib/tasks/move-carry.ts

@@ -9,6 +9,7 @@
 
 import type Database from "better-sqlite3";
 import { db } from "../db";
+import { orchestratorOf } from "./starter";
 
 // table, column, and how the id sits in it: the whole value, `task:<id>`, or
 // the tail of a `<condition>:<id>` key.
@@ -59,9 +60,19 @@ export const CARRIED_COLUMNS = [
 ] as const;
 
 /** The orchestration columns that make a session "an orchestrator's task". */
+// started_by carries as the orchestrator only: a task a plain task started is
+// not held, and a mirror reading it as held would relay to the wrong session.
 export const orchestrationOf = (session: Record<string, unknown>) =>
   Object.fromEntries(
-    CARRIED_COLUMNS.map((c) => [c, session[c] ?? null] as const)
+    CARRIED_COLUMNS.map(
+      (c) =>
+        [
+          c,
+          c === "started_by"
+            ? orchestratorOf(session.started_by as string | null)
+            : (session[c] ?? null),
+        ] as const
+    )
   );
 
 export function carryTaskState(

package/lib/tasks/move-guard.ts

@@ -10,10 +10,11 @@ import { db, type Session } from "../db";
 import { escalations } from "../orchestrator/gates";
 import { taskSubject } from "../orchestrator/asks";
 import { usesGitCrypt } from "../worktree-add";
+import { orchestratorOf } from "./starter";
 
 /** 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;
+  if (orchestratorOf(session.started_by) || session.held_by_device) return true;
   return !!db
     .prepare(
       `SELECT 1 FROM orchestrator_starts WHERE kind != 'stack' AND target = ? LIMIT 1`

package/lib/tasks/move.ts

@@ -30,6 +30,7 @@ import { dropSessionDatabase } from "../project-config/database";
 import { releaseChat } from "../chat/runner";
 import { collectWhileMoving } from "../chat/hold";
 import { packChat, stopChatForMove } from "./move-chat";
+import { orchestratorOf as starterOrchestrator } from "./starter";
 import {
   isClaudeSessionId,
   latestSessionId,
@@ -122,11 +123,12 @@ function orchestratorOf(
 ): { 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;
+  const by = starterOrchestrator(session.started_by);
+  if (!by) return undefined;
+  const o = db.prepare(`SELECT name FROM sessions WHERE id = ?`).get(by) as
+    | { name: string }
+    | undefined;
+  return o ? { id: by, name: o.name } : undefined;
 }
 
 // What an orchestrator's task carries besides its work (the orchestrator's

package/lib/tasks/pause.ts

@@ -28,7 +28,7 @@ import { launchPending } from "./launch-gate";
 import { killTmux } from "./start";
 import { launchClaude } from "../agents/launch";
 import { resolveRole, sessionWorkspace, taskOverride } from "../models/resolve";
-import { sessionRole } from "../models/roles";
+import { sessionRole } from "../models/session-role";
 import { holdingEscalations } from "../orchestrator/gates";
 import { openBySubject, workSubject } from "../orchestrator/asks";
 import { queueEventOnce } from "../orchestrator/events";