agent-relay-orchestrator 0.78.6 → 0.78.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.78.6",
+  "version": "0.78.8",
   "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.56"
+    "agent-relay-sdk": "0.2.58"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/control.ts

@@ -95,6 +95,8 @@ export function createControlHandler(
           repoRoot: typeof command.params.repoRoot === "string" ? command.params.repoRoot : undefined,
           worktreePath: typeof command.params.worktreePath === "string" ? command.params.worktreePath : undefined,
           branch: typeof command.params.branch === "string" ? command.params.branch : undefined,
+          baseRef: typeof command.params.baseRef === "string" ? command.params.baseRef : undefined,
+          baseSha: typeof command.params.baseSha === "string" ? command.params.baseSha : undefined,
           deleteBranch: command.params.deleteBranch !== false,
           workspacesRoot: workspacesRoot(config.baseDir),
         });

package/src/quota-poller.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { createServer } from "node:net";
 import { join } from "node:path";
 import {
@@ -7,14 +7,10 @@ import {
   QUOTA_FAILURE_LOG_INTERVAL_MS,
   QUOTA_FAST_RETRY_MS,
   QuotaCollectionError,
-  collectClaudeQuotaSample,
   collectCodexQuotaSample,
-  credentialAccountKey,
   normalizeProviderQuotaConfig,
   providerQuotaErrorFromCollectorError,
   quotaRetryAfterMs,
-  readClaudeOAuthAccessToken,
-  resolveStableClaudeQuotaIdentity,
   resolveStableCodexQuotaIdentityFromHome,
   type ProviderQuotaIdentity,
   type ProviderQuotaSample,
@@ -177,11 +173,6 @@ export class OrchestratorQuotaPoller {
     // A disabled provider (#605) is collected from at all: no discovery → no
     // polling/API calls, leases released by releaseRemovedCandidates, and no
     // skip-marker row (disabled is intentional, not a credential failure).
-    if (this.config.providers.includes("claude") && this.configFor("claude").enabled) {
-      const found = await this.discoverClaudeCandidates();
-      candidates.push(...found.candidates);
-      if (found.skipReason) skips.push({ provider: "claude", reason: found.skipReason });
-    }
     if (this.config.providers.includes("codex") && this.configFor("codex").enabled) {
       const found = await this.discoverCodexCandidates();
       candidates.push(...found.candidates);
@@ -194,33 +185,6 @@ export class OrchestratorQuotaPoller {
     return { candidates: [...deduped.values()], skips };
   }
 
-  private async discoverClaudeCandidates(): Promise<{ candidates: QuotaCandidate[]; skipReason?: string }> {
-    const credentialsPaths = [
-      join(this.config.env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), ".credentials.json"),
-      ...providerHomeCredentialPaths("claude", ".credentials.json"),
-    ];
-    const candidates: QuotaCandidate[] = [];
-    for (const accessToken of [
-      this.config.env.CLAUDE_CODE_OAUTH_TOKEN,
-      process.env.CLAUDE_CODE_OAUTH_TOKEN,
-      ...claudeSetupTokenEnvPaths(this.config).map((path) => readEnvFileValue(path, "CLAUDE_CODE_OAUTH_TOKEN")),
-    ]) {
-      if (accessToken) candidates.push(claudeBearerCandidate(accessToken));
-    }
-    for (const credentialsPath of credentialsPaths) {
-      const accessToken = await readClaudeOAuthAccessToken(credentialsPath);
-      if (!accessToken) continue;
-      const identity = await resolveStableClaudeQuotaIdentity({ credentialsPath });
-      candidates.push({ ...(identity ?? claudeBearerCandidate(accessToken)), credentialsPath, accessToken });
-    }
-    if (candidates.length === 0) {
-      const reason = "no usable Claude bearer token on this host";
-      this.logOnce("claude:no-usable-bearer", `quota refresh skipped for claude: ${reason}`);
-      return { candidates, skipReason: reason };
-    }
-    return { candidates };
-  }
-
   private async discoverCodexCandidates(): Promise<{ candidates: QuotaCandidate[]; skipReason?: string }> {
     const homes = [
       this.config.env.CODEX_HOME || process.env.CODEX_HOME || join(homedir(), ".codex"),
@@ -355,14 +319,6 @@ export class OrchestratorQuotaPoller {
   }
 
   private async collect(candidate: QuotaCandidate): Promise<ProviderQuotaSample> {
-    if (candidate.provider === "claude") {
-      return collectClaudeQuotaSample({
-        agentId: this.sourceAgentId(),
-        accessToken: candidate.accessToken,
-        credentialsPath: candidate.credentialsPath,
-        fetchImpl: this.options.fetchImpl,
-      });
-    }
     if (candidate.provider === "codex") {
       return collectCodexQuotaSample({
         agentId: this.sourceAgentId(),
@@ -497,49 +453,6 @@ function providerHomeConfigDirs(provider: "claude" | "codex", markerFile: string
   return dirs;
 }
 
-function providerHomeCredentialPaths(provider: "claude", markerFile: string): string[] {
-  return providerHomeConfigDirs(provider, markerFile).map((dir) => join(dir, markerFile));
-}
-
-function claudeSetupTokenEnvPaths(config: OrchestratorConfig): string[] {
-  const configDir = config.env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
-  return [
-    join(configDir, "setup-token.env"),
-    ...providerHomeConfigDirs("claude", "setup-token.env").map((dir) => join(dir, "setup-token.env")),
-  ];
-}
-
-function claudeBearerCandidate(accessToken: string): QuotaCandidate {
-  return {
-    provider: "claude",
-    accountKey: credentialAccountKey(accessToken),
-    accessToken,
-  };
-}
-
-function readEnvFileValue(path: string, key: string): string | undefined {
-  try {
-    for (const line of readFileSync(path, "utf8").split(/\r?\n/)) {
-      const match = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=\\s*(.*)\\s*$`).exec(line);
-      if (!match) continue;
-      return cleanEnvValue(match[1] ?? "");
-    }
-  } catch {
-    return undefined;
-  }
-  return undefined;
-}
-
-function cleanEnvValue(value: string): string | undefined {
-  let cleaned = value.trim();
-  if (!cleaned) return undefined;
-  const quote = cleaned[0];
-  if ((quote === "'" || quote === "\"") && cleaned.endsWith(quote)) {
-    cleaned = cleaned.slice(1, -1);
-  }
-  return cleaned.trim() || undefined;
-}
-
 function safeReadDir(path: string): string[] {
   try {
     return readdirSync(path, { withFileTypes: true })

package/src/workspace-probe/cleanup.ts

@@ -22,7 +22,7 @@ function owningRepoRoot(worktreePath: string, fallback: string): string {
   return existsSync(root) ? root : fallback;
 }
 
-export function cleanupWorkspace(workspace: { repoRoot?: string; worktreePath?: string; id?: string; branch?: string; deleteBranch?: boolean; workspacesRoot?: string }): { workspaceId?: string; removed: boolean; worktreePath?: string; branchDeleted?: boolean; containerRemoved?: boolean } {
+export function cleanupWorkspace(workspace: { repoRoot?: string; worktreePath?: string; id?: string; branch?: string; baseRef?: string; baseSha?: string; deleteBranch?: boolean; workspacesRoot?: string }): { workspaceId?: string; removed: boolean; worktreePath?: string; branchDeleted?: boolean; branchPreservedReason?: string; containerRemoved?: boolean } {
   if (!workspace.worktreePath) throw new Error("worktreePath required");
   const path = resolve(workspace.worktreePath);
   const recordedRepo = workspace.repoRoot ? resolve(workspace.repoRoot) : path;
@@ -38,14 +38,61 @@ export function cleanupWorkspace(workspace: { repoRoot?: string; worktreePath?:
     throw new Error(result.stderr || `worktree ${path} still present after \`git worktree remove\` (repo ${repo})`);
   }
   // Once the worktree is gone the agent/... branch is litter — delete it so
-  // branches don't accumulate. Best-effort: don't fail cleanup if it can't
-  // (e.g. branch already gone, or checked out elsewhere).
+  // branches don't accumulate. First prove it has no unlanded commits, because
+  // deleting the branch ref is what can make committed-but-unlanded work
+  // unreachable after a crashed worker (#614).
   let branchDeleted = false;
+  let branchPreservedReason: string | undefined;
   if (workspace.branch && workspace.deleteBranch !== false) {
-    branchDeleted = git(["branch", "-D", workspace.branch], repo).ok;
+    const safety = branchSafeToDelete(repo, workspace.branch, workspace.baseRef, workspace.baseSha);
+    if (safety.safe) {
+      branchDeleted = git(["branch", "-D", workspace.branch], repo).ok;
+      if (!branchDeleted) branchPreservedReason = "branch delete failed";
+    } else {
+      branchPreservedReason = safety.reason;
+    }
   }
   const containerRemoved = workspace.workspacesRoot ? removeEmptyContainer(dirname(path), resolve(workspace.workspacesRoot)) : false;
-  return { workspaceId: workspace.id, removed: true, worktreePath: path, branchDeleted, containerRemoved };
+  return { workspaceId: workspace.id, removed: true, worktreePath: path, branchDeleted, ...(branchPreservedReason ? { branchPreservedReason } : {}), containerRemoved };
+}
+
+function branchSafeToDelete(repo: string, branch: string, baseRef?: string, baseSha?: string): { safe: boolean; reason?: string } {
+  const branchRef = resolveCommit(repo, branch) ? branch : resolveCommit(repo, `refs/heads/${branch}`) ? `refs/heads/${branch}` : undefined;
+  if (!branchRef) return { safe: true };
+
+  const base = resolveCleanupBase(repo, baseRef, baseSha);
+  if (!base) return { safe: false, reason: "base ref unavailable" };
+
+  const counts = 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]);
+  if (!Number.isFinite(ahead)) return { safe: false, reason: "ahead count unavailable" };
+  if (ahead === 0) return { safe: true };
+
+  const cherryBase = upstreamRef(repo, base) ?? base;
+  if (git(["diff", "--quiet", cherryBase, branchRef], repo).ok) return { safe: true };
+  const cherry = git(["cherry", cherryBase, branchRef], repo);
+  if (!cherry.ok) return { safe: false, reason: cherry.stderr || "unmerged commit check unavailable" };
+  const unmergedAhead = cherry.stdout ? cherry.stdout.split("\n").filter((line) => line.startsWith("+")).length : 0;
+  return unmergedAhead === 0
+    ? { safe: true }
+    : { safe: false, reason: `${unmergedAhead} unlanded commit(s)` };
+}
+
+function resolveCleanupBase(repo: string, baseRef?: string, baseSha?: string): string | undefined {
+  for (const candidate of [baseRef, baseSha, "main", "master"]) {
+    if (candidate && resolveCommit(repo, candidate)) return candidate;
+  }
+  return undefined;
+}
+
+function resolveCommit(repo: string, ref: string): boolean {
+  return git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], repo).ok;
+}
+
+function upstreamRef(repo: string, base: string): string | undefined {
+  const res = git(["rev-parse", "--abbrev-ref", `${base}@{upstream}`], repo);
+  return res.ok && res.stdout ? res.stdout : undefined;
 }
 
 export function sweepEmptyWorkspaceContainers(wsRoot: string): string[] {

package/src/workspace-probe/git-state.ts

@@ -138,7 +138,7 @@ export function reconcileWorkspace(workspace: { id?: string; repoRoot?: string;
   // detection can only under-report, so this never deletes unmerged work.
   const empty = gitState.error === undefined && gitState.dirtyCount === 0 && ((gitState.ahead ?? 0) === 0 || gitState.landed === true);
   if (empty) {
-    cleanupWorkspace({ id: workspace.id, repoRoot: workspace.repoRoot, worktreePath: workspace.worktreePath, branch: workspace.branch });
+    cleanupWorkspace({ id: workspace.id, repoRoot: workspace.repoRoot, worktreePath: workspace.worktreePath, branch: workspace.branch, baseRef: workspace.baseRef, baseSha: workspace.baseSha });
     return { workspaceId: workspace.id, removed: true, status: "cleaned", gitState };
   }
   return { workspaceId: workspace.id, removed: false, status: "review_requested", gitState };