agent-relay-orchestrator 0.120.4 → 0.120.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.120.4",
+  "version": "0.120.6",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.3",
-    "agent-relay-sdk": "0.2.109",
+    "agent-relay-sdk": "0.2.111",
     "callmux": "0.23.0"
   },
   "devDependencies": {

package/src/shared-callmux.ts

@@ -347,10 +347,12 @@ function callmuxServerFromMcpServer(server: Record<string, unknown>): Record<str
     out.command = server.command;
     if (Array.isArray(server.args)) out.args = server.args.filter((arg): arg is string => typeof arg === "string");
     if (isRecord(server.env)) out.env = server.env;
+    if (isRecord(server.configEnv)) out.configEnv = server.configEnv;
   } else if (typeof server.url === "string") {
     out.url = server.url;
     if (server.type === "sse") out.transport = "sse";
     if (isRecord(server.headers)) out.headers = server.headers;
+    if (isRecord(server.configEnv)) out.configEnv = server.configEnv;
   }
   return out;
 }

package/src/workspace-probe/cleanup.ts

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, rmdirSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { git } from "../git";
+import { protectedTipRef } from "./protected-tip";
 
 export async function pruneWorktrees(input: { repoRoot?: string }): Promise<{ repoRoot: string; pruned: boolean; output?: string; error?: string }> {
   const repo = resolve(input.repoRoot ?? ".");
@@ -51,7 +52,7 @@ export async function cleanupWorkspace(workspace: { repoRoot?: string; worktreeP
   let branchDeleted = false;
   let branchPreservedReason: string | undefined;
   if (workspace.branch && workspace.deleteBranch !== false) {
-    const safety = await branchSafeToDelete(repo, workspace.branch, workspace.baseRef, workspace.baseSha);
+    const safety = await branchSafeToDelete(repo, workspace.branch, workspace.baseRef, workspace.baseSha, workspace.id);
     if (safety.safe) {
       branchDeleted = (await git(["branch", "-D", workspace.branch], repo)).ok;
       if (!branchDeleted) branchPreservedReason = "branch delete failed";
@@ -95,13 +96,19 @@ async function snapshotDirtyWorktree(worktreePath: string, workspaceId: string |
   return updated.ok ? ref : undefined;
 }
 
-export async function branchSafeToDelete(repo: string, branch: string, baseRef?: string, baseSha?: string): Promise<{ safe: boolean; reason?: string }> {
+export async function branchSafeToDelete(repo: string, branch: string, baseRef?: string, baseSha?: string, workspaceId?: string): Promise<{ safe: boolean; reason?: string }> {
   const branchRef = await resolveCommit(repo, branch) ? branch : await resolveCommit(repo, `refs/heads/${branch}`) ? `refs/heads/${branch}` : undefined;
-  if (!branchRef) return { safe: true };
+  const rescueRef = protectedTipRef(workspaceId);
+  const rescueTip = rescueRef ? await resolveCommitSha(repo, rescueRef) : undefined;
+  if (!branchRef && !rescueTip) return { safe: true };
 
   const base = await resolveCleanupBase(repo, baseRef, baseSha);
   if (!base) return { safe: false, reason: "base ref unavailable" };
 
+  const rescue = await rescueTipSafety(repo, base, rescueRef, rescueTip);
+  if (!rescue.safe) return rescue;
+  if (!branchRef) return { safe: true };
+
   const counts = await git(["rev-list", "--left-right", "--count", `${base}...${branchRef}`], repo);
   if (!counts.ok || !counts.stdout) return { safe: false, reason: counts.stderr || "ahead count unavailable" };
   const ahead = Number(counts.stdout.split(/\s+/)[1]);
@@ -118,9 +125,9 @@ export async function branchSafeToDelete(repo: string, branch: string, baseRef?:
     : { safe: false, reason: `${unmergedAhead} unlanded commit(s)` };
 }
 
-export async function deleteBranchIfSafe(repo: string, branch: string, baseRef?: string, baseSha?: string, signal?: AbortSignal): Promise<{ branchDeleted: boolean; branchPreservedReason?: string }> {
+export async function deleteBranchIfSafe(repo: string, branch: string, baseRef?: string, baseSha?: string, signal?: AbortSignal, workspaceId?: string): Promise<{ branchDeleted: boolean; branchPreservedReason?: string }> {
   if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error("workspace merge aborted");
-  const safety = await branchSafeToDelete(repo, branch, baseRef, baseSha);
+  const safety = await branchSafeToDelete(repo, branch, baseRef, baseSha, workspaceId);
   if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error("workspace merge aborted");
   if (!safety.safe) return { branchDeleted: false, ...(safety.reason ? { branchPreservedReason: safety.reason } : {}) };
   const branchDeleted = (await git(["branch", "-D", branch], repo, { signal })).ok;
@@ -138,6 +145,25 @@ async function resolveCommit(repo: string, ref: string): Promise<boolean> {
   return (await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], repo)).ok;
 }
 
+async function resolveCommitSha(repo: string, ref: string): Promise<string | undefined> {
+  const result = await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], repo);
+  return result.ok && result.stdout ? result.stdout.trim() : undefined;
+}
+
+async function rescueTipSafety(repo: string, base: string, ref: string | undefined, tip: string | undefined): Promise<{ safe: boolean; reason?: string }> {
+  if (!ref || !tip) return { safe: true };
+  if ((await git(["merge-base", "--is-ancestor", tip, base], repo)).ok) return { safe: true };
+
+  const cherryBase = await upstreamRef(repo, base) ?? base;
+  if ((await git(["diff", "--quiet", cherryBase, tip], repo)).ok) return { safe: true };
+  const cherry = await git(["cherry", cherryBase, tip], repo);
+  if (!cherry.ok) return { safe: false, reason: cherry.stderr || "recoverable workspace tip check unavailable" };
+  const unmergedAhead = cherry.stdout ? cherry.stdout.split("\n").filter((line) => line.startsWith("+")).length : 0;
+  return unmergedAhead === 0
+    ? { safe: true }
+    : { safe: false, reason: `recoverable tip ${tip.slice(0, 12)} at ${ref} has ${unmergedAhead} unlanded commit(s)` };
+}
+
 async function upstreamRef(repo: string, base: string): Promise<string | undefined> {
   const res = await git(["rev-parse", "--abbrev-ref", `${base}@{upstream}`], repo);
   return res.ok && res.stdout ? res.stdout : undefined;

package/src/workspace-probe/merge.ts

@@ -11,7 +11,7 @@ import { type MergePhase, mergePhaseTimeoutMs, throwIfMergeAborted, withMergePha
 import { nextBranchName } from "./names";
 import { parseWorktrees, shortBranch } from "./parse";
 import { applyPrMergeState } from "./pr-preview";
-import { protectWorkspaceTip } from "./protected-tip";
+import { protectWorkspaceTip, recoverableProtectedTip } from "./protected-tip";
 import { json, resolveRequestedPath } from "./request";
 import type { WorkspaceMergeInput } from "./types";
 import { workspacePushEnabled } from "../config";
@@ -213,9 +213,8 @@ function logBaseWorktreeStrand(base: string, worktreePath: string, sync: BaseWor
 
 export async function previewBranchMerge(input: {
   repoRoot?: string;
-  branch?: string;
-  baseRef?: string;
-  baseSha?: string;
+  branch?: string; workspaceId?: string;
+  baseRef?: string; baseSha?: string;
   strategy?: "pr" | "rebase-ff" | "auto";
   checkPr?: boolean;
 }): Promise<WorkspaceMergePreview | null> {
@@ -231,10 +230,11 @@ export async function previewBranchMerge(input: {
     ? input.strategy
     : remote && gh && baseBranch ? "pr" : "rebase-ff";
   const branchRef = await resolveBranchRef(repoRoot, input.branch);
-  if (!branchRef) return null;
+  const recoverable = branchRef ? undefined : await recoverableProtectedTip(repoRoot, input.workspaceId);
+  if (!branchRef && !recoverable) return null;
 
-  const gitState = await populateMergeState(repoRoot, branchRef, { dirty: false, dirtyCount: 0, branch: input.branch }, input.baseRef, input.baseSha);
-  const base: WorkspaceMergePreview = { strategy, hasRemote: remote, ghAvailable: gh, baseRef: baseBranch ?? gitState.baseRef };
+  const gitState = await populateMergeState(repoRoot, branchRef ?? recoverable!.recoverableTip, { dirty: false, dirtyCount: 0, branch: input.branch }, input.baseRef, input.baseSha);
+  const base: WorkspaceMergePreview = { strategy, hasRemote: remote, ghAvailable: gh, baseRef: baseBranch ?? gitState.baseRef, ...recoverable };
   if (!gitState.baseRef) return { ...base, error: "base ref unavailable" };
   base.ahead = gitState.ahead;
   base.unmergedAhead = gitState.unmergedAhead;
@@ -278,7 +278,7 @@ export async function branchMergePreviewResponse(url: URL, baseDir: string): Pro
     const strategy = url.searchParams.get("strategy");
     const preview = await previewBranchMerge({
       repoRoot: resolveRequestedPath(url.searchParams.get("repoRoot") || undefined, baseDir),
-      branch: url.searchParams.get("branch") || undefined,
+      branch: url.searchParams.get("branch") || undefined, workspaceId: url.searchParams.get("workspaceId") || undefined,
       baseRef: url.searchParams.get("baseRef") || undefined,
       baseSha: url.searchParams.get("baseSha") || undefined,
       strategy: validPreviewStrategy(strategy),
@@ -533,7 +533,7 @@ async function resolveNoopMerge(
       throwIfMergeAborted(signal);
       if ((await mergeGit(["checkout", "-B", fresh, start], worktreePath, "rebase", `workspace merge noop recycle worktree to ${fresh}`, signal)).ok) {
         const baseSha = (await mergeGit(["rev-parse", start], worktreePath, "rebase", `workspace merge resolve noop recycle start ${start}`, signal)).stdout || undefined;
-        const deleteResult = await deleteBranchIfSafe(ownerRepo, branch, undefined, baseSha ?? start, signal);
+        const deleteResult = await deleteBranchIfSafe(ownerRepo, branch, undefined, baseSha ?? start, signal, input.id);
         // Recycled onto base, which may declare deps the symlinked node_modules lacks (#51).
         const depsRefresh = await refreshWorkspaceDeps(ownerRepo, worktreePath);
         throwIfMergeAborted(signal);
@@ -551,7 +551,7 @@ async function resolveNoopMerge(
     throwIfMergeAborted(signal);
     const removed = await mergeGit(["worktree", "remove", "--force", worktreePath], ownerRepo, "cleanup", "workspace merge remove noop worktree", signal);
     const worktreeRemoved = removed.ok;
-    const deleteResult = worktreeRemoved ? await deleteBranchIfSafe(ownerRepo, branch, preview.baseRef, undefined, signal) : { branchDeleted: false };
+    const deleteResult = worktreeRemoved ? await deleteBranchIfSafe(ownerRepo, branch, preview.baseRef, undefined, signal, input.id) : { branchDeleted: false };
     return head({ status: "merged", noop: true, worktreeRemoved, ...deleteResult, ...pushedStranded, error: undefined });
   }
   return head({ status: "merged", noop: true, ...pushedStranded, error: undefined });
@@ -1103,7 +1103,7 @@ async function mergeRebaseFf(
     throwIfMergeAborted(signal);
     const switched = await mergeGit(["checkout", "-B", fresh, base], worktreePath, "rebase", `workspace merge recycle worktree to ${fresh}`, signal);
     if (switched.ok) {
-      const deleteResult = await deleteBranchIfSafe(ownerRepo, branch, undefined, baseTip, signal);
+      const deleteResult = await deleteBranchIfSafe(ownerRepo, branch, undefined, baseTip, signal, input.id);
       // The worktree just moved onto the advanced base, which may declare deps the
       // shared (symlinked) node_modules lacks. Re-provision so the recycled session
       // continues from a buildable state (issue #51). No-op when nothing is stale.
@@ -1118,6 +1118,6 @@ async function mergeRebaseFf(
   throwIfMergeAborted(signal);
   const removed = await mergeGit(["worktree", "remove", "--force", worktreePath], ownerRepo, "cleanup", "workspace merge remove landed worktree", signal);
   const worktreeRemoved = removed.ok;
-  const deleteResult = worktreeRemoved ? await deleteBranchIfSafe(ownerRepo, branch, undefined, baseTip, signal) : { branchDeleted: false };
+  const deleteResult = worktreeRemoved ? await deleteBranchIfSafe(ownerRepo, branch, undefined, baseTip, signal, input.id) : { branchDeleted: false };
   return head({ merged: true, status: "merged", mergedSha: headSha, baseSha: baseTip, subject: landedSubject, worktreeRemoved, ...deleteResult, pushed, ...baseWorktreeSyncField, ...gateWarningsField, error: undefined });
 }

package/src/workspace-probe/protected-tip.ts

@@ -14,11 +14,18 @@ function gitError(result: Awaited<ReturnType<typeof git>>, fallback: string): st
   return result.stderr || result.stdout || fallback;
 }
 
-function protectedTipRef(workspaceId: string | undefined): string | undefined {
+export function protectedTipRef(workspaceId: string | undefined): string | undefined {
   const safe = workspaceId?.replace(/[^A-Za-z0-9._/-]+/g, "-").replace(/^\/+|\/+$/g, "").slice(0, 180);
   return safe ? `refs/agent-relay/workspace-tips/${safe}` : undefined;
 }
 
+export async function recoverableProtectedTip(cwd: string, workspaceId: string | undefined): Promise<{ recoverableTip: string; recoverableTipRef: string; reason: string } | undefined> {
+  const ref = protectedTipRef(workspaceId);
+  if (!ref) return undefined;
+  const tip = await readCommit(cwd, ref);
+  return tip ? { recoverableTip: tip, recoverableTipRef: ref, reason: "branch ref is gone but protected workspace tip is recoverable" } : undefined;
+}
+
 function discardedTipRef(ref: string): string {
   return `${ref}-discarded-${Date.now()}`;
 }