agent-relay-orchestrator 0.91.3 → 0.92.0

package/src/workspace-probe/probe.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import type { WorkspaceMode, WorkspaceProbe } from "agent-relay-sdk";
@@ -61,6 +61,63 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
     };
   }
 
+  // #635 — attach to an existing worktree instead of creating a fresh one.
+  if (input.resumeWorkspace?.mode === "attach") {
+    const resume = input.resumeWorkspace;
+    const wtp = resume.worktreePath;
+    if (!wtp) throw new Error("resumeWorkspace attach: worktreePath is required");
+    if (!existsSync(wtp)) throw new Error(`resumeWorkspace attach: worktree does not exist: ${wtp}`);
+    return {
+      cwd: wtp,
+      workspace: {
+        ...(resume.workspaceId ? { id: resume.workspaceId } : { id: workspaceId(input) }),
+        mode: "isolated",
+        requestedMode,
+        repoRoot: probe.repoRoot,
+        sourceCwd,
+        worktreePath: wtp,
+        branch: resume.branch,
+        ...(resume.baseRef ? { baseRef: resume.baseRef } : {}),
+        ...(resume.baseSha ? { baseSha: resume.baseSha } : {}),
+        status: "active",
+        probe,
+      },
+    };
+  }
+
+  // #635 — create a fresh worktree off an existing branch's HEAD instead of main's HEAD.
+  if (input.resumeWorkspace?.mode === "branch-from") {
+    const resume = input.resumeWorkspace;
+    const repoRoot = probe.repoRoot;
+    const baseSha = requireGit(["rev-parse", resume.branch], repoRoot);
+    const id = workspaceId(input);
+    const branch = await availableBranch(repoRoot, branchName(input, id));
+    const workspaceRoot = input.workspaceRoot ? resolve(input.workspaceRoot) : workspacesRoot(homedir());
+    const worktreePath = join(workspaceRoot, repoSlug(repoRoot), id);
+    mkdirSync(join(worktreePath, ".."), { recursive: true });
+    requireGit(["worktree", "add", "-b", branch, worktreePath, baseSha], repoRoot);
+    const deps = provisionWorkspaceDeps(repoRoot, worktreePath);
+    const symlinks = provisionWorkspaceSymlinks(repoRoot, worktreePath, input.workspaceSymlinks ?? []);
+    return {
+      cwd: worktreePath,
+      workspace: {
+        id,
+        mode: "isolated",
+        requestedMode,
+        repoRoot,
+        sourceCwd,
+        worktreePath,
+        branch,
+        baseRef: resume.branch,
+        baseSha,
+        status: "active",
+        deps,
+        ...(symlinks.linked.length || symlinks.errors ? { symlinks } : {}),
+        probe,
+      },
+    };
+  }
+
   const id = workspaceId(input);
   const repoRoot = probe.repoRoot;
   const baseRef = terminalBaseRef(repoRoot, probe.branch);

package/src/workspace-probe/types.ts

@@ -1,6 +1,21 @@
 import type { WorkspaceMetadata, WorkspaceMode } from "agent-relay-sdk";
 import type { WorkspaceMergeResult } from "agent-relay-sdk";
 
+/** Attach to or branch off an existing managed worktree instead of creating a fresh one (#635). */
+export interface ResumeWorkspaceTarget {
+  branch: string;
+  /** `attach` = reuse the existing worktree as-is (crash recovery). `branch-from` = new worktree off the existing branch HEAD. */
+  mode: "attach" | "branch-from";
+  /** Resolved worktree path from the relay DB. For `attach`: must exist on disk. For `branch-from`: unused (HEAD resolved from branch). */
+  worktreePath?: string;
+  /** Existing workspace DB id. For `attach`: passed back so the relay reuses the same record (avoids duplicates). */
+  workspaceId?: string;
+  /** Preserved baseRef from the original workspace. For `attach` only. */
+  baseRef?: string;
+  /** Preserved baseSha from the original workspace. For `attach` only. */
+  baseSha?: string;
+}
+
 export interface WorkspaceResolutionInput {
   cwd: string;
   label?: string;
@@ -11,6 +26,8 @@ export interface WorkspaceResolutionInput {
   workspaceSymlinks?: string[];
   automationId?: string;
   automationRunId?: string;
+  /** #635 — attach to or branch off an existing worktree instead of creating a fresh one. */
+  resumeWorkspace?: ResumeWorkspaceTarget;
 }
 
 export interface WorkspaceResolution {