agent-relay-orchestrator 0.20.0 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.11"
+    "agent-relay-sdk": "0.2.13"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/relay.ts

@@ -3,7 +3,7 @@ import type { ProviderProbeCache } from "./provider-probe";
 import { detectSelfSupervision } from "./self-supervision";
 import { GIT_SHA, ORCHESTRATOR_PROTOCOL_VERSION, VERSION, runtimeMetadata } from "./version";
 import type { WorkspaceMetadata, WorkspaceMode, ManagedSessionExitDiagnostics as SdkManagedSessionExitDiagnostics } from "agent-relay-sdk";
-import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import { ReconnectionManager, RelayHttpClient } from "agent-relay-sdk";
 
 export interface RelayClient {
   register(): Promise<void>;
@@ -58,10 +58,11 @@ export interface RelayCommand {
   status: string;
 }
 
-const BACKOFF_SCHEDULE_MS = [
-  30_000, 60_000, 120_000, 240_000, 480_000, 960_000,
-];
-const MAX_BACKOFF_MS = 3_600_000; // 1 hour
+// Reconnect backoff: 30s → 1m → 2m → … capped at 1h, with jitter. Replaces the
+// former fixed BACKOFF_SCHEDULE_MS staircase — see SDK ReconnectionManager.
+const RECONNECT_INITIAL_MS = 30_000;
+const RECONNECT_MAX_MS = 3_600_000; // 1 hour
+const RECONNECT_JITTER_MS = 1_000;
 
 export function buildRegistrationMeta(
   config: Pick<OrchestratorConfig, "tmuxPrefix">,
@@ -88,26 +89,17 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
   const agentId = `orchestrator-${config.id}`;
   let heartbeatTimer: Timer | null = null;
   let connected = false;
-  let backoffIndex = 0;
+  const reconnectMgr = new ReconnectionManager({ initialMs: RECONNECT_INITIAL_MS, maxMs: RECONNECT_MAX_MS, jitterMs: RECONNECT_JITTER_MS });
   let cursorFloor = 0;
   let apiUrl: string | undefined;
-  let runtimeToken: string | undefined;
-
-  function headers(): Record<string, string> {
-    const h: Record<string, string> = { "Content-Type": "application/json" };
-    const token = runtimeToken ?? config.token;
-    if (token) h[RELAY_TOKEN_HEADER] = token;
-    return h;
-  }
+  // Shared transport: auth-header injection + timeout + typed errors. The
+  // orchestrator-control endpoints have no typed method, so route them through
+  // the generic request() escape hatch. setToken() swaps in the runtime token
+  // the relay mints at registration.
+  const http = new RelayHttpClient({ baseUrl: config.relayUrl, token: config.token });
 
   async function apiCall(method: string, path: string, body?: unknown): Promise<Response> {
-    const url = `${config.relayUrl}/api${path}`;
-    const res = await fetch(url, {
-      method,
-      headers: headers(),
-      body: body ? JSON.stringify(body) : undefined,
-    });
-    return res;
+    return http.request(method, `/api${path}`, body);
   }
 
   async function register(): Promise<void> {
@@ -135,9 +127,9 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
       throw new Error(`Failed to register orchestrator: ${res.status} ${err}`);
     }
     const registered = await res.json().catch(() => null) as { runtimeToken?: { token?: string } } | null;
-    if (registered?.runtimeToken?.token) runtimeToken = registered.runtimeToken.token;
+    if (registered?.runtimeToken?.token) http.setToken(registered.runtimeToken.token);
     connected = true;
-    backoffIndex = 0;
+    reconnectMgr.reset();
 
     // Bootstrap message cursor
     const cursor = await apiCall("GET", "/messages/cursor");
@@ -168,7 +160,7 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
       if (!connected) {
         console.error("[orchestrator] Reconnected to relay");
         connected = true;
-        backoffIndex = 0;
+        reconnectMgr.reset();
       }
     } catch (err) {
       if (connected) {
@@ -180,12 +172,9 @@ export function createRelayClient(config: OrchestratorConfig, probeCache: Provid
   }
 
   async function reconnect(): Promise<void> {
-    const delay = backoffIndex < BACKOFF_SCHEDULE_MS.length
-      ? BACKOFF_SCHEDULE_MS[backoffIndex]!
-      : MAX_BACKOFF_MS;
-    backoffIndex = Math.min(backoffIndex + 1, BACKOFF_SCHEDULE_MS.length);
-    console.error(`[orchestrator] Reconnecting in ${Math.round(delay / 1000)}s...`);
-    await new Promise((resolve) => setTimeout(resolve, delay));
+    const delayMs = reconnectMgr.nextDelay();
+    console.error(`[orchestrator] Reconnecting in ${Math.round(delayMs / 1000)}s...`);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
     try {
       await register();
     } catch {

package/src/workspace-probe.ts

@@ -789,7 +789,9 @@ export function previewWorkspaceMerge(input: { worktreePath?: string; baseRef?:
       : gitState.landed
         ? "already merged into base (squash/cherry-pick)"
         : "no commits to merge";
-    return { ...base, reason };
+    // Nothing to land and the worktree is clean — a no-op the land path resolves to
+    // a terminal state rather than parking forever in the steward queue (#230).
+    return { ...base, reason, noop: true };
   }
   if (gitState.baseRef && input.worktreePath) {
     const conflict = predictConflict(resolve(input.worktreePath), gitState.baseRef);
@@ -820,6 +822,10 @@ export function mergeWorkspace(input: WorkspaceMergeInput): WorkspaceMergeResult
 
   if (preview.missing) return head({ status: "cleaned", error: preview.reason });
   if (preview.error) return head({ status: "review_requested", error: preview.error });
+  // 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.reason) return head({ status: "review_requested", error: preview.reason });
   if (preview.conflict) return head({ conflict: true, status: "conflict", error: "merge would conflict with base" });
 
@@ -827,6 +833,31 @@ export function mergeWorkspace(input: WorkspaceMergeInput): WorkspaceMergeResult
   return mergeRebaseFf(input, worktreePath, repoRoot, branch, preview, head);
 }
 
+/**
+ * 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.
+ */
+function resolveNoopMerge(
+  input: WorkspaceMergeInput,
+  worktreePath: string,
+  repoRoot: string,
+  branch: string | undefined,
+  head: (field: Partial<WorkspaceMergeResult>) => WorkspaceMergeResult,
+): WorkspaceMergeResult {
+  if (input.deleteBranch !== false && branch) {
+    const removed = git(["worktree", "remove", "--force", worktreePath], repoRoot);
+    const worktreeRemoved = removed.ok;
+    const branchDeleted = worktreeRemoved ? git(["branch", "-D", branch], repoRoot).ok : false;
+    return head({ status: "merged", noop: true, worktreeRemoved, branchDeleted, error: undefined });
+  }
+  return head({ status: "merged", noop: true, error: undefined });
+}
+
 function mergePr(
   input: WorkspaceMergeInput,
   worktreePath: string,