agent-relay-orchestrator 0.91.2 → 0.91.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.91.2",
+  "version": "0.91.4",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "src/**/*.ts",
     "!src/**/*.test.ts",
+    "vendor/**",
     "README.md"
   ],
   "scripts": {
@@ -16,7 +17,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.70"
+    "agent-relay-sdk": "0.2.71"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/git.ts

@@ -22,6 +22,20 @@ export function git(args: string[], cwd: string): GitResult {
   };
 }
 
+/** Run `git -C cwd <args>` and preserve stdout exactly for path-safe parsers. */
+export function gitRaw(args: string[], cwd: string): GitResult {
+  const proc = Bun.spawnSync(["git", "-C", cwd, ...args], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    ok: proc.exitCode === 0,
+    stdout: proc.stdout.toString(),
+    stderr: proc.stderr.toString().trim(),
+  };
+}
+
 /** Like {@link git} but throws on a non-zero exit, returning stdout on success. */
 export function requireGit(args: string[], cwd: string): string {
   const result = git(args, cwd);

package/src/shared-callmux.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { errMessage, isRecord } from "agent-relay-sdk";
 import type { OrchestratorConfig } from "./config";
 import { agentRelayHome } from "./config";
@@ -54,6 +54,15 @@ export interface SharedCallmuxSupervisorDeps {
   setTimeout(fn: () => void, ms: number): Timer;
   clearTimeout(timer: Timer): void;
   log(message: string): void;
+  report(snapshot: SharedCallmuxHealthSnapshot): void;
+}
+
+export interface SharedCallmuxHealthSnapshot {
+  state: "disabled" | "missing" | "starting" | "running" | "unhealthy" | "restarting" | "stopped";
+  url: string;
+  command?: string;
+  reason?: string;
+  pid?: number;
 }
 
 export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefined> = process.env): SharedCallmuxOptions {
@@ -63,13 +72,13 @@ export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefin
   const port = numberEnv(env[SHARED_CALLMUX_PORT_ENV]) ?? parsed?.port ?? DEFAULT_SHARED_CALLMUX_PORT;
   const url = explicitUrl ?? `http://${host}:${port}/mcp`;
   return {
-    command: env[SHARED_CALLMUX_COMMAND_ENV] || "callmux",
+    command: env[SHARED_CALLMUX_COMMAND_ENV] || bundledCallmuxCommand() || "callmux",
     host,
     port,
     url,
     configPath: env[SHARED_CALLMUX_CONFIG_ENV] || join(agentRelayHome(), "callmux", "shared-listener.json"),
     sourceConfigPath: env[SHARED_CALLMUX_SOURCE_CONFIG_ENV] || env.CALLMUX_CONFIG || join(homedir(), ".config", "callmux", "config.json"),
-    enabled: env[SHARED_CALLMUX_ENABLE_ENV] === "1",
+    enabled: !envOff(env[SHARED_CALLMUX_ENABLE_ENV]),
   };
 }
 
@@ -91,6 +100,8 @@ export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "confi
     maxConcurrency: numberFromRecord(source, "maxConcurrency") ?? 20,
     callTimeoutMs: numberFromRecord(source, "callTimeoutMs") ?? 180_000,
     outputFormat: stringFromRecord(source, "outputFormat") ?? "auto",
+    // Relay workers consume only proxied tokenlean+github tools; suppress callmux meta-tools.
+    exposeMetaTools: false,
   };
   mkdirSync(dirname(opts.configPath), { recursive: true });
   writeFileSync(opts.configPath, JSON.stringify(generated, null, 2) + "\n", { mode: 0o600 });
@@ -115,14 +126,17 @@ export class SharedCallmuxSupervisor {
 
   start(): void {
     if (!this.opts.enabled) {
-      this.deps.log("[orchestrator] shared callmux listener disabled (set AGENT_RELAY_SHARED_CALLMUX_ENABLE=1 to enable)");
+      this.deps.log("[orchestrator] shared callmux listener disabled by AGENT_RELAY_SHARED_CALLMUX_ENABLE=0");
+      this.report("disabled", "global kill-switch");
       return;
     }
     this.deps.log(`[orchestrator] Shared callmux listener: ${this.opts.url}`);
     if (!this.deps.which(this.opts.command)) {
       this.deps.log("[orchestrator] shared callmux not found — shared listener dormant");
+      this.report("missing", "command not found");
       return;
     }
+    this.report("starting");
     this.spawn();
     this.healthTimer = this.deps.setInterval(() => {
       void this.checkHealth();
@@ -153,9 +167,11 @@ export class SharedCallmuxSupervisor {
     }
     if (ok) {
       this.backoffMs = this.timing.restartBaseMs ?? 1_000;
+      this.report("running", undefined, this.proc?.pid);
       return true;
     }
     this.deps.log(`[orchestrator] Shared callmux readiness failed at ${readyUrl}; restarting`);
+    this.report("unhealthy", "readiness failed", this.proc?.pid);
     this.restart("readiness failed");
     return false;
   }
@@ -174,20 +190,24 @@ export class SharedCallmuxSupervisor {
       proc = this.deps.spawn(this.opts.command, args, { env, cwd: homedir() });
     } catch (err) {
       this.deps.log(`[orchestrator] Shared callmux listener failed to start: ${errMessage(err)}; scheduling restart`);
+      this.report("restarting", errMessage(err));
       this.scheduleRestart();
       return;
     }
     this.proc = proc;
     this.deps.log(`[orchestrator] Started shared callmux listener pid=${proc.pid ?? "unknown"}`);
+    this.report("running", undefined, proc.pid);
     proc.exited.then((code) => {
       if (this.proc !== proc || this.stopping) return;
       this.proc = null;
       this.deps.log(`[orchestrator] Shared callmux listener exited (${code ?? "signal"}); scheduling restart`);
+      this.report("restarting", `exited ${code ?? "signal"}`);
       this.scheduleRestart();
     }).catch((err) => {
       if (this.proc !== proc || this.stopping) return;
       this.proc = null;
       this.deps.log(`[orchestrator] Shared callmux listener exit watcher failed: ${err}`);
+      this.report("restarting", errMessage(err));
       this.scheduleRestart();
     });
   }
@@ -198,9 +218,20 @@ export class SharedCallmuxSupervisor {
       this.proc.kill("SIGTERM");
       this.proc = null;
     }
+    this.report("restarting", reason);
     this.scheduleRestart();
   }
 
+  private report(state: SharedCallmuxHealthSnapshot["state"], reason?: string, pid?: number): void {
+    this.deps.report({
+      state,
+      url: this.opts.url,
+      command: this.opts.command,
+      ...(reason ? { reason } : {}),
+      ...(pid ? { pid } : {}),
+    });
+  }
+
   private scheduleRestart(): void {
     if (this.stopping || this.restartTimer) return;
     const delay = this.backoffMs;
@@ -235,15 +266,26 @@ function defaultDeps(): SharedCallmuxSupervisorDeps {
     setTimeout: (fn, ms) => setTimeout(fn, ms),
     clearTimeout: (timer) => clearTimeout(timer),
     log: (message) => console.error(message),
+    report: (snapshot) => console.error(`[orchestrator] shared callmux status ${snapshot.state}${snapshot.reason ? `: ${snapshot.reason}` : ""}`),
   };
 }
 
+export function bundledCallmuxCommand(): string | null {
+  const candidate = resolve(import.meta.dir, "../vendor/callmux/bin/callmux.js");
+  return existsSync(candidate) ? candidate : null;
+}
+
 function resolveCommand(command: string): string | null {
   if (isAbsolute(command)) return existsSync(command) ? command : null;
   if (command.includes("/")) return existsSync(command) ? command : null;
   return Bun.which(command);
 }
 
+function envOff(value: string | undefined): boolean {
+  if (value === undefined || value === null || value === "") return false;
+  return ["0", "false", "off", "no"].includes(value.trim().toLowerCase());
+}
+
 function readJsonObject(path: string): Record<string, unknown> {
   if (!existsSync(path)) return {};
   const parsed = JSON.parse(readFileSync(path, "utf8"));

package/src/terminal-stream.ts

@@ -603,6 +603,12 @@ class SessionStream {
       // can't re-apply on top of it (the duplicate-text race). %output that arrived AFTER the
       // capture stayed in `pending` and applies on top of the repaint via the trailing flush.
       this.drainPreCaptureDeltas();
+      if (!forceAbort && this.broadcastState !== "ground") {
+        this.resyncDirty = true;
+        this.flush(); // let the sequence tail complete normally; retry with a fresh capture
+        if (!this.resyncTimer) this.resyncTimer = setTimeout(() => void this.doResync(), RESYNC_GROUND_RETRY_MS);
+        return;
+      }
       if (!repaint || this.closed || this.subscribers.size === 0) {
         this.flush(); // release any post-capture deltas normally (no repaint to inject)
         return;

package/src/workspace-probe/merge.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import type { WorkspaceMergePreview, WorkspaceMergeResult } from "agent-relay-sdk";
-import { git } from "../git";
+import { git, gitRaw } from "../git";
 import { prMergedState } from "../workspace-pr";
 import { refreshWorkspaceDeps } from "./deps";
 import { populateMergeState, resolveBranchRef, syncBaseFromOrigin, upstreamRef, workspaceGitState } from "./git-state";
@@ -65,6 +65,79 @@ function worktreeForBranch(repoRoot: string, branch: string): { path: string; di
   return { path: match.path, dirty: status.ok ? status.stdout.length > 0 : true };
 }
 
+function splitNul(stdout: string): string[] {
+  return stdout.split("\0").filter(Boolean);
+}
+
+function dirtyPathSet(worktreePath: string): Set<string> {
+  const status = gitRaw(["status", "--porcelain=v1", "-z", "--untracked-files=all"], worktreePath);
+  if (!status.ok) return new Set<string>();
+  const paths = new Set<string>();
+  const entries = splitNul(status.stdout);
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i] ?? "";
+    if (entry.length < 4) continue;
+    const code = entry.slice(0, 2);
+    const path = entry.slice(3);
+    paths.add(path);
+    if (code[0] === "R" || code[0] === "C") i += 1;
+  }
+  return paths;
+}
+
+function changedPathList(worktreePath: string, oldBaseTip: string, newBaseTip: string): string[] {
+  const diff = gitRaw(["diff", "--name-only", "-z", oldBaseTip, newBaseTip], worktreePath);
+  return diff.ok ? splitNul(diff.stdout) : [];
+}
+
+function restorePathsFromHead(worktreePath: string, paths: string[]): boolean {
+  if (paths.length === 0) return true;
+  return git(["restore", "--staged", "--worktree", "--", ...paths], worktreePath).ok;
+}
+
+function resetIndexPathsToHead(worktreePath: string, paths: string[]): boolean {
+  if (paths.length === 0) return true;
+  return git(["reset", "-q", "HEAD", "--", ...paths], worktreePath).ok;
+}
+
+function logBaseWorktreeSyncWarning(base: string, worktreePath: string, message: string): void {
+  console.error(`[orchestrator] Warning: advanced ${base} but could not fully sync dirty base worktree ${worktreePath}: ${message}`);
+}
+
+/**
+ * After a dirty checked-out base is advanced with ref plumbing, bring the checkout forward
+ * without clobbering human WIP. `read-tree -m -u old new` is the primary mechanism: it
+ * updates clean paths in the index and worktree and refuses before overwriting local edits.
+ * If it refuses, preserve the land by leaving the ref advanced, restore only paths that were
+ * clean before the ref move, and normalize conflicting landed paths to unstaged edits.
+ */
+function syncDirtyBaseWorktreeAfterRefAdvance(
+  base: string,
+  baseWorktree: { path: string; dirty: boolean } | undefined,
+  oldBaseTip: string,
+  newBaseTip: string,
+  dirtyBefore: Set<string> | undefined,
+): void {
+  if (!baseWorktree?.dirty || !dirtyBefore) return;
+  const readTree = git(["read-tree", "-m", "-u", oldBaseTip, newBaseTip], baseWorktree.path);
+  if (readTree.ok) return;
+
+  const changedPaths = changedPathList(baseWorktree.path, oldBaseTip, newBaseTip);
+  const cleanChangedPaths = changedPaths.filter((path) => !dirtyBefore.has(path));
+  const dirtyChangedPaths = changedPaths.filter((path) => dirtyBefore.has(path));
+  const restoredClean = restorePathsFromHead(baseWorktree.path, cleanChangedPaths);
+  const resetDirtyIndex = resetIndexPathsToHead(baseWorktree.path, dirtyChangedPaths);
+  logBaseWorktreeSyncWarning(
+    base,
+    baseWorktree.path,
+    [
+      readTree.stderr || "read-tree refused local changes",
+      restoredClean ? undefined : "failed to restore clean landed paths",
+      resetDirtyIndex ? undefined : "failed to reset conflicting path index",
+    ].filter(Boolean).join("; "),
+  );
+}
+
 // Populate a preview's PR fields from `gh` ground truth; returns whether the PR is merged
 // (#168/#304). One home for the PR-landing rule so the worktree- and repoRoot-based previews
 // can't drift. On a merge it stamps the merge SHA so the relay can finalize a parked pr land.
@@ -441,16 +514,19 @@ function syncLocalBaseToUpstream(
   // Sync IN the base worktree only when it's clean — that keeps its working tree consistent
   // with the advanced ref (the pristine home-repo checkout). When the base worktree is dirty
   // (#644: a human's WIP in the shared checkout) we must NOT refuse and stall the whole repo's
-  // lands: advance the ref directly with update-ref instead. This is immune to the checkout's
-  // state and never reads or writes the human's working tree — their uncommitted work is left
-  // exactly as-is (the ref moves underneath; their files on disk are untouched).
+  // lands: advance the ref directly with update-ref, then best-effort sync the checked-out
+  // index/worktree forward for paths that are not human-modified (#681).
   if (baseWorktree && !baseWorktree.dirty) {
     const ff = git(["merge", "--ff-only", upstream], baseWorktree.path);
     if (!ff.ok) return { ok: false, error: ff.stderr || `failed to fast-forward ${base} to ${upstream}` };
     return { ok: true };
   }
-  const update = git(["update-ref", `refs/heads/${base}`, upstreamSha], repoRoot);
+  const oldBaseTip = git(["rev-parse", base], repoRoot).stdout;
+  const dirtyBefore = baseWorktree?.dirty ? dirtyPathSet(baseWorktree.path) : undefined;
+  const updateArgs = oldBaseTip ? ["update-ref", `refs/heads/${base}`, upstreamSha, oldBaseTip] : ["update-ref", `refs/heads/${base}`, upstreamSha];
+  const update = git(updateArgs, repoRoot);
   if (!update.ok) return { ok: false, error: update.stderr || `failed to advance ${base} to ${upstream}` };
+  if (oldBaseTip) syncDirtyBaseWorktreeAfterRefAdvance(base, baseWorktree, oldBaseTip, upstreamSha, dirtyBefore);
   return { ok: true };
 }
 
@@ -512,11 +588,11 @@ function mergeRebaseFf(
   // only when it exists AND is clean — that keeps its working tree consistent with the
   // advanced ref (the pristine home-repo checkout). When the base worktree is dirty
   // (#644: a human's WIP in the shared checkout) we must NOT refuse and stall every lane's
-  // land: fall through to ref-plumbing (update-ref / synthesized no-ff merge) below, which
-  // advances refs/heads/<base> without reading or touching that working tree. The human's
-  // uncommitted work is left exactly as-is — the ref moves underneath, their files untouched.
+  // land: fall through to ref-plumbing (update-ref / synthesized no-ff merge) below, then
+  // best-effort sync clean landed paths in the dirty checkout while preserving WIP (#681).
   let baseTip = headSha;
   const baseWorktree = worktreeForBranch(repoRoot, base);
+  const dirtyBasePathsBefore = baseWorktree?.dirty ? dirtyPathSet(baseWorktree.path) : undefined;
   if (baseWorktree && !baseWorktree.dirty) {
     if (behind === 0) {
       const ff = git(["merge", "--ff-only", branch], baseWorktree.path);
@@ -533,13 +609,18 @@ function mergeRebaseFf(
       baseTip = git(["rev-parse", "HEAD"], baseWorktree.path).stdout;
     }
   } else if (behind === 0) {
-    const update = git(["update-ref", `refs/heads/${base}`, headSha], repoRoot);
+    const oldBaseTip = git(["rev-parse", base], repoRoot).stdout;
+    const update = oldBaseTip
+      ? git(["update-ref", `refs/heads/${base}`, headSha, oldBaseTip], repoRoot)
+      : git(["update-ref", `refs/heads/${base}`, headSha], repoRoot);
     if (!update.ok) return head({ status: "review_requested", error: update.stderr || "failed to advance base ref" });
+    if (oldBaseTip) syncDirtyBaseWorktreeAfterRefAdvance(base, baseWorktree, oldBaseTip, headSha, dirtyBasePathsBefore);
   } else {
     const baseSha = git(["rev-parse", base], repoRoot).stdout;
     const merged = recordNoFfMerge(repoRoot, base, baseSha, headSha, landMergeMessage(branch, landedSubject));
     if (!merged.ok) return head(merged.conflict ? { conflict: true, status: "conflict", error: merged.error } : { status: "review_requested", error: merged.error });
     baseTip = merged.mergeSha;
+    syncDirtyBaseWorktreeAfterRefAdvance(base, baseWorktree, baseSha, baseTip, dirtyBasePathsBefore);
   }
 
   // Publish the advanced base so local and origin converge (#190). We verified