agent-relay-orchestrator 0.35.1 → 0.35.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.35.1",
+  "version": "0.35.3",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {

package/src/control.ts

@@ -216,6 +216,7 @@ function spawnOptionsFromRecord(source: Record<string, any>, config: Orchestrato
     spawnRequestId: typeof source.spawnRequestId === "string" ? source.spawnRequestId : undefined,
     automationId: typeof source.automationId === "string" ? source.automationId : undefined,
     automationRunId: typeof source.automationRunId === "string" ? source.automationRunId : undefined,
+    requestedVia: typeof source.requestedVia === "string" ? source.requestedVia : undefined,
   };
 }
 

package/src/spawn.ts

@@ -37,6 +37,9 @@ export interface SpawnOptions {
   spawnRequestId?: string;
   automationId?: string;
   automationRunId?: string;
+  /** How the spawn was requested (`mcp` = an agent via the MCP surface, else dashboard/CLI). Drives
+   * the origin tag so an MCP-spawned worker isn't mislabeled `dashboard-spawned` (#330). */
+  requestedVia?: string;
 }
 
 interface SessionInfo {
@@ -222,7 +225,11 @@ export function buildEnv(opts: SpawnOptions & { label: string; agentId: string }
     AGENT_RELAY_APPROVAL: opts.approvalMode || "guarded",
     ...(opts.profile ? { AGENT_RELAY_AGENT_PROFILE: opts.profile } : {}),
     ...(opts.agentProfile ? { AGENT_RELAY_AGENT_PROFILE_JSON: JSON.stringify(opts.agentProfile) } : {}),
-    AGENT_RELAY_TAGS: [...new Set(["headless", "dashboard-spawned", config.hostname, ...(opts.tags ?? [])])].join(","),
+    // #330 — tag by TRUE origin. An MCP spawn (an agent spawning a helper) is `agent-spawned`, not
+    // `dashboard-spawned`; the old blanket `dashboard-spawned` mislabeled every headless spawn as
+    // dashboard-originated. Dashboard/CLI/automation spawns (no `requestedVia: "mcp"`) keep the
+    // `dashboard-spawned` tag the smoke test and UI filter on.
+    AGENT_RELAY_TAGS: [...new Set(["headless", opts.requestedVia === "mcp" ? "agent-spawned" : "dashboard-spawned", config.hostname, ...(opts.tags ?? [])])].join(","),
     AGENT_RELAY_CAPS: [...new Set(opts.capabilities ?? [])].join(","),
     AGENT_RELAY_CAPABILITIES: [...new Set(opts.capabilities ?? [])].join(","),
     AGENT_RELAY_HEADLESS: "1",

package/src/workspace-probe.ts

@@ -90,6 +90,14 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
   const requestedMode = input.workspaceMode ?? "inherit";
   const sourceCwd = resolve(input.cwd);
   const probe = await probeWorkspace(sourceCwd);
+  // #328 backstop — an EXPLICIT `isolated` request needs a git repo to branch off. Without one,
+  // the old code silently downgraded to `shared` (no branch, no worktree, no signal), so a worker
+  // asked for an isolated branch instead edited a live tree. Fail loud and actionable instead of
+  // fabricating a different mode than the caller asked for. (`inherit`→isolated, from a policy or
+  // automation in a non-repo dir, keeps its legitimate shared fallback below.)
+  if (requestedMode === "isolated" && !probe.isGitRepo) {
+    throw new Error(`workspaceMode "isolated" requires a git repo, but ${sourceCwd} is not one. Pass an explicit cwd under a repo, or omit cwd to inherit the caller's.`);
+  }
   const inheritedMode = input.policyName || input.automationRunId ? "isolated" : "shared";
   const mode: WorkspaceMode = requestedMode === "inherit" ? inheritedMode : requestedMode;
   if (mode !== "isolated" || !probe.isGitRepo || !probe.repoRoot) {
@@ -915,7 +923,7 @@ export function mergeWorkspace(input: WorkspaceMergeInput): WorkspaceMergeResult
   // Nothing to land (ahead=0, clean): the branch tree is already in base. Resolve it
   // to a terminal state so it leaves the steward queue instead of looping forever in
   // review_requested (#230). Reclaim the spent worktree/branch when the owner is gone.
-  if (preview.noop) return resolveNoopMerge(input, worktreePath, repoRoot, branch, head);
+  if (preview.noop) return resolveNoopMerge(input, worktreePath, repoRoot, branch, preview, head);
   if (preview.reason) return head({ status: "review_requested", error: preview.reason });
   if (preview.conflict) return head({ conflict: true, status: "conflict", error: "merge would conflict with base" });
 
@@ -924,22 +932,45 @@ export function mergeWorkspace(input: WorkspaceMergeInput): WorkspaceMergeResult
 }
 
 /**
- * Resolve a no-op land (#230): ahead=0 with a clean worktree, so the branch's tree
- * is already contained in base (never diverged, or already landed via
- * squash/cherry-pick/PR). There's nothing to merge — mark the workspace terminal
- * (`merged`, `noop: true`) so it leaves the steward queue. When the owner is gone
- * (`deleteBranch !== false`) the spent worktree/branch are reclaimed too, mirroring a
- * terminal land; a live owner keeps its worktree (cleanup reclaims it later). Safe:
- * there is no unmerged work to lose.
+ * Resolve a no-op land (#230): ahead=0 with a clean worktree, so the branch's tree is
+ * already contained in base. Nothing to merge; no unmerged work to lose either way.
+ * Liveness splits the outcome, mirroring the real-land path in {@link mergeRebaseFf}:
+ *  - Live owner (`deleteBranch === false`, from owner liveness #204): recycle onto a
+ *    fresh branch cut from base and return to `active` (land-and-continue, #206). A noop
+ *    land must NOT brick a still-connected session — terminal `merged` here strands the
+ *    agent with no checkout once cleanup reclaims the worktree (#327).
+ *  - Gone owner: reclaim the spent worktree/branch and go terminal `merged`.
  */
 function resolveNoopMerge(
   input: WorkspaceMergeInput,
   worktreePath: string,
   repoRoot: string,
   branch: string | undefined,
+  preview: WorkspaceMergePreview,
   head: (field: Partial<WorkspaceMergeResult>) => WorkspaceMergeResult,
 ): WorkspaceMergeResult {
-  if (input.deleteBranch !== false && branch) {
+  // Live owner (#327): recycle-to-continue instead of bricking the session.
+  if (input.deleteBranch === false) {
+    const base = preview.baseRef;
+    if (base && branch) {
+      const fresh = nextBranchName(repoRoot, branch);
+      if (git(["checkout", "-B", fresh, base], worktreePath).ok) {
+        // Old branch's tree is already in base (that's what noop means) — safe to drop.
+        const oldDeleted = git(["branch", "-D", branch], repoRoot).ok;
+        const baseSha = git(["rev-parse", base], worktreePath).stdout || undefined;
+        // Recycled onto base, which may declare deps the symlinked node_modules lacks (#51).
+        const depsRefresh = refreshWorkspaceDeps(repoRoot, worktreePath);
+        const reportDeps = depsRefresh.refreshed || depsRefresh.stale || depsRefresh.error;
+        // merged:false → no `branch.landed` notice (nothing landed); newBranch makes the
+        // relay repoint the row and return it to `active` rather than terminal `merged`.
+        return head({ merged: false, noop: true, status: "active", baseSha, worktreeRemoved: false, branch: fresh, newBranch: fresh, branchDeleted: oldDeleted, ...(reportDeps ? { depsRefresh } : {}), error: undefined });
+      }
+    }
+    // No base or checkout failed — stay live on the current branch, don't strand at `merged`.
+    return head({ merged: false, noop: true, status: "active", worktreeRemoved: false, branchDeleted: false, error: undefined });
+  }
+  // Owner is gone — reclaim the spent worktree/branch and go terminal.
+  if (branch) {
     const removed = git(["worktree", "remove", "--force", worktreePath], repoRoot);
     const worktreeRemoved = removed.ok;
     const branchDeleted = worktreeRemoved ? git(["branch", "-D", branch], repoRoot).ok : false;