agent-relay-orchestrator 0.112.0 → 0.114.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.112.0",
+  "version": "0.114.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.1",
-    "agent-relay-sdk": "0.2.95",
+    "agent-relay-sdk": "0.2.96",
     "callmux": "0.23.0"
   },
   "devDependencies": {

package/src/command-poller.ts

@@ -0,0 +1,43 @@
+import type { RelayClient, RelayCommand } from "./relay";
+
+interface CommandPollerControl {
+  handleCommand(command: RelayCommand): Promise<boolean>;
+}
+
+interface CommandPollerOptions {
+  relay: Pick<RelayClient, "connected" | "pollCommands">;
+  control: CommandPollerControl;
+  log?: (message: string) => void;
+}
+
+export function createCommandPoller({ relay, control, log = console.error }: CommandPollerOptions) {
+  let inFlight = false;
+
+  async function tick(): Promise<boolean> {
+    if (!relay.connected || inFlight) return false;
+    inFlight = true;
+    try {
+      const commands = await relay.pollCommands();
+      if (commands.length > 0) {
+        log(`[orchestrator] Received ${commands.length} command(s)`);
+      }
+      for (const command of commands) {
+        log(`[orchestrator] Handling command: ${command.type} ${command.id}`);
+        await control.handleCommand(command);
+      }
+      return true;
+    } catch (err) {
+      log(`[orchestrator] Poll error: ${err}`);
+      return false;
+    } finally {
+      inFlight = false;
+    }
+  }
+
+  return {
+    tick,
+    get inFlight() {
+      return inFlight;
+    },
+  };
+}

package/src/index.ts

@@ -12,6 +12,7 @@ import { sweepEmptyWorkspaceContainers, workspacesRoot } from "./workspace-probe
 import { startOrchestratorMaintenanceScheduler } from "./maintenance";
 import { OrchestratorQuotaPoller } from "./quota-poller";
 import { SharedCallmuxSupervisor } from "./shared-callmux";
+import { createCommandPoller } from "./command-poller";
 
 const args = process.argv.slice(2);
 
@@ -123,20 +124,9 @@ async function startup(): Promise<void> {
 }
 
 function startPolling(): void {
+  const commandPoller = createCommandPoller({ relay, control });
   pollTimer = setInterval(async () => {
-    if (!relay.connected) return;
-    try {
-      const commands = await relay.pollCommands();
-      if (commands.length > 0) {
-        console.error(`[orchestrator] Received ${commands.length} command(s)`);
-      }
-      for (const command of commands) {
-        console.error(`[orchestrator] Handling command: ${command.type} ${command.id}`);
-        await control.handleCommand(command);
-      }
-    } catch (err) {
-      console.error(`[orchestrator] Poll error: ${err}`);
-    }
+    await commandPoller.tick();
   }, POLL_INTERVAL_MS);
 }
 

package/src/shared-callmux.ts

@@ -15,7 +15,6 @@ export const SHARED_CALLMUX_ENABLE_ENV = "AGENT_RELAY_SHARED_CALLMUX_ENABLE";
 
 export const DEFAULT_SHARED_CALLMUX_HOST = "127.0.0.1";
 export const DEFAULT_SHARED_CALLMUX_PORT = 4861;
-export const SHARED_CALLMUX_SERVER_NAMES = ["tokenlean", "github"] as const;
 
 const CONFIG_SCHEMA = "callmux/schema.json";
 const GITHUB_TOOLS = [
@@ -44,6 +43,7 @@ export interface SharedCallmuxSupervisorDeps {
   clearInterval(timer: Timer): void;
   setTimeout(fn: () => void, ms: number): Timer;
   clearTimeout(timer: Timer): void;
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   log(message: string): void;
   report(snapshot: SharedCallmuxHealthSnapshot): void;
 }
@@ -67,7 +67,7 @@ export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefin
     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: !envOff(env[SHARED_CALLMUX_ENABLE_ENV]),
+  enabled: !envOff(env[SHARED_CALLMUX_ENABLE_ENV]),
   };
 }
 
@@ -75,13 +75,12 @@ export function sharedMcpListenerUrl(): string {
   return sharedCallmuxOptionsFromEnv().url;
 }
 
-export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath">): CallmuxConfig {
+export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath"> & { registryServers?: CallmuxConfig["servers"] }): CallmuxConfig {
   const source = readJsonObject(opts.sourceConfigPath);
   const sourceServers = isRecord(source.servers) ? source.servers : {};
-  const servers: CallmuxConfig["servers"] = {
-    tokenlean: cloneServer(sourceServers.tokenlean) ?? defaultTokenleanServer(),
-    github: cloneServer(sourceServers.github) ?? defaultGithubServer(),
-  };
+  const servers = opts.registryServers && Object.keys(opts.registryServers).length > 0
+    ? cloneServers(opts.registryServers)
+    : fallbackSharedServers(sourceServers);
   const generated: CallmuxConfig = {
     servers,
     cacheTtlSeconds: numberFromRecord(source, "cacheTtlSeconds") ?? 10,
@@ -97,6 +96,36 @@ export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "confi
   return generated;
 }
 
+export async function fetchSharedCallmuxRegistryServers(
+  config: Pick<OrchestratorConfig, "relayUrl" | "token">,
+  deps: Pick<SharedCallmuxSupervisorDeps, "fetch" | "log"> = { fetch: globalThis.fetch.bind(globalThis), log: () => {} },
+): Promise<CallmuxConfig["servers"] | undefined> {
+  try {
+    const url = new URL("/api/provisioning/capabilities?kind=mcp", config.relayUrl);
+    const headers: Record<string, string> = {};
+    if (config.token) headers.Authorization = `Bearer ${config.token}`;
+    const res = await deps.fetch(url, { headers });
+    if (!res.ok) {
+      deps.log(`[orchestrator] Shared callmux registry fetch failed: ${res.status}`);
+      return undefined;
+    }
+    const payload = await res.json().catch(() => null) as unknown;
+    const capabilities = isRecord(payload) && Array.isArray(payload.capabilities) ? payload.capabilities : [];
+    const servers: CallmuxConfig["servers"] = {};
+    for (const capability of capabilities) {
+      if (!isRecord(capability) || !Array.isArray(capability.variants)) continue;
+      for (const variant of capability.variants) {
+        const entry = callmuxServerFromProvisioningVariant(variant);
+        if (entry) servers[entry.name] = entry.server;
+      }
+    }
+    return Object.keys(servers).length > 0 ? servers : undefined;
+  } catch (err) {
+    deps.log(`[orchestrator] Shared callmux registry fetch failed: ${errMessage(err)}`);
+    return undefined;
+  }
+}
+
 export class SharedCallmuxSupervisor {
   private listener: ProgrammaticListener | null = null;
   private readonly onStatus = (snapshot: ListenerHealthSnapshot) => this.reportCallmuxHealth(snapshot);
@@ -159,8 +188,10 @@ export class SharedCallmuxSupervisor {
   private async open(): Promise<void> {
     if (this.stopping || this.listener) return;
     try {
-      const persistedConfig = writeSharedCallmuxConfig(this.opts);
+      const registryServers = await fetchSharedCallmuxRegistryServers(this.config, this.deps);
+      const persistedConfig = writeSharedCallmuxConfig({ ...this.opts, ...(registryServers ? { registryServers } : {}) });
       const config = withRuntimeEnv(persistedConfig, {
+        ...process.env,
         ...this.config.env,
         [SHARED_MCP_URL_ENV]: this.opts.url,
       });
@@ -234,6 +265,7 @@ function defaultDeps(): SharedCallmuxSupervisorDeps {
     clearInterval: (timer) => clearInterval(timer),
     setTimeout: (fn, ms) => setTimeout(fn, ms),
     clearTimeout: (timer) => clearTimeout(timer),
+    fetch: globalThis.fetch.bind(globalThis),
     log: (message) => console.error(message),
     report: (snapshot) => console.error(`[orchestrator] shared callmux status ${snapshot.state}${snapshot.reason ? `: ${snapshot.reason}` : ""}`),
   };
@@ -262,20 +294,81 @@ function cloneServer(value: unknown): CallmuxConfig["servers"][string] | undefin
   return JSON.parse(JSON.stringify(value)) as CallmuxConfig["servers"][string];
 }
 
-function withRuntimeEnv(config: CallmuxConfig, env: Record<string, string>): CallmuxConfig {
-  const envEntries = Object.entries(env).filter(([, value]) => typeof value === "string");
-  if (envEntries.length === 0) return config;
-  const inheritedEnv = Object.fromEntries(envEntries);
+function cloneServers(value: CallmuxConfig["servers"]): CallmuxConfig["servers"] {
+  return Object.fromEntries(Object.entries(value).map(([name, server]) => [name, cloneServer(server) ?? server]));
+}
+
+function fallbackSharedServers(sourceServers: Record<string, unknown>): CallmuxConfig["servers"] {
+  return {
+    tokenlean: cloneServer(sourceServers.tokenlean) ?? defaultTokenleanServer(),
+    github: cloneServer(sourceServers.github) ?? defaultGithubServer(),
+  };
+}
+
+function callmuxServerFromProvisioningVariant(value: unknown): { name: string; server: CallmuxConfig["servers"][string] } | null {
+  if (!isRecord(value) || value.enabled === false || value.approvalStatus === "pending" || value.validationStatus === "invalid") return null;
+  if (typeof value.name !== "string" || !value.name) return null;
+  const definition = value.definition;
+  if (!isRecord(definition) || definition.kind !== "mcp" || !isRecord(definition.server)) return null;
+  const metadata = isRecord(definition.metadata) ? definition.metadata : {};
+  const provenance = isRecord(value.provenance) ? value.provenance : {};
+  if (metadata.sharedListenerEligible !== true && provenance.sharedListenerEligible !== true) return null;
+  const rawCallmuxServer = isRecord(metadata.callmuxServer) ? metadata.callmuxServer : callmuxServerFromMcpServer(definition.server);
+  const server = cloneServer(mergeConfigEnv(rawCallmuxServer));
+  return server ? { name: value.name, server } : null;
+}
+
+function mergeConfigEnv(server: Record<string, unknown>): Record<string, unknown> {
+  if (!isRecord(server.configEnv)) return server;
+  const { configEnv, ...rest } = server;
+  return {
+    ...rest,
+    env: { ...(configEnv as Record<string, string>), ...(isRecord(rest.env) ? (rest.env as Record<string, string>) : {}) },
+  };
+}
+
+function callmuxServerFromMcpServer(server: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (typeof server.command === "string") {
+    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;
+  } 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;
+  }
+  return out;
+}
+
+function withRuntimeEnv(config: CallmuxConfig, env: Record<string, string | undefined>): CallmuxConfig {
+  const inheritedEnv: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") inheritedEnv[key] = value;
+  }
+  if (Object.keys(inheritedEnv).length === 0) return config;
   const servers = Object.fromEntries(Object.entries(config.servers).map(([name, server]) => {
-    if (!("command" in server)) return [name, server];
+    const rawHeaders = "headers" in server && isRecord(server.headers) ? server.headers as Record<string, string> : undefined;
+    const headers = rawHeaders ? expandStringRecordPlaceholders(rawHeaders, inheritedEnv) : undefined;
+    if (!("command" in server)) return [name, { ...server, ...(headers ? { headers } : {}) }];
+    const serverEnv = isRecord(server.env) ? expandStringRecordPlaceholders(server.env as Record<string, string>, inheritedEnv) : {};
     return [name, {
       ...server,
-      env: { ...inheritedEnv, ...(isRecord(server.env) ? server.env as Record<string, string> : {}) },
+      env: { ...inheritedEnv, ...serverEnv },
+      ...(headers ? { headers } : {}),
     }];
   }));
   return { ...config, servers };
 }
 
+function expandStringRecordPlaceholders(value: Record<string, string>, env: Record<string, string>): Record<string, string> {
+  return Object.fromEntries(Object.entries(value).map(([key, raw]) => [key, expandEnvPlaceholders(raw, env)]));
+}
+
+function expandEnvPlaceholders(value: string, env: Record<string, string>): string {
+  return value.replace(/\$\{?([A-Z_][A-Z0-9_]*)\}?/g, (match, key: string) => env[key] ?? match);
+}
+
 function defaultTokenleanServer(): CallmuxConfig["servers"][string] {
   return {
     command: "tl-mcp",

package/src/spawn/spawn-agent.ts

@@ -3,15 +3,45 @@ import type { OrchestratorConfig } from "../config";
 import { resolveSpawnWorkspace, workspacesRoot } from "../workspace-probe";
 import type { ManagedAgentReport } from "../relay";
 import { buildEnv, buildRunnerCommand, defaultSpawnLabel, isWithinBaseDir, sessionName } from "./command";
-import { addSessionRecord, ensureLogDir, ensureRunnerInfoDir, logFilePath, runnerInfoPath, sessionReportFields } from "./runtime";
+import { addSessionRecord, currentSessionPid, findSessionRecord, ensureLogDir, ensureRunnerInfoDir, logFilePath, runnerInfoPath, sessionRecordLiveness, sessionReportFields } from "./runtime";
 import { managedAgentId } from "./sessions";
 import { spawnRunner } from "./supervisor";
 import type { SpawnOptions } from "./types";
 
+interface SpawnAgentDeps {
+  resolveSpawnWorkspace: typeof resolveSpawnWorkspace;
+  spawnRunner: typeof spawnRunner;
+  addSessionRecord: typeof addSessionRecord;
+  findSessionRecord: typeof findSessionRecord;
+  sessionRecordLiveness: typeof sessionRecordLiveness;
+  currentSessionPid: typeof currentSessionPid;
+  sessionReportFields: typeof sessionReportFields;
+  ensureLogDir: typeof ensureLogDir;
+  ensureRunnerInfoDir: typeof ensureRunnerInfoDir;
+  logFilePath: typeof logFilePath;
+  runnerInfoPath: typeof runnerInfoPath;
+}
+
+const defaultSpawnAgentDeps: SpawnAgentDeps = {
+  resolveSpawnWorkspace,
+  spawnRunner,
+  addSessionRecord,
+  findSessionRecord,
+  sessionRecordLiveness,
+  currentSessionPid,
+  sessionReportFields,
+  ensureLogDir,
+  ensureRunnerInfoDir,
+  logFilePath,
+  runnerInfoPath,
+};
+
 export async function spawnAgent(
   opts: SpawnOptions,
   config: OrchestratorConfig,
+  deps: Partial<SpawnAgentDeps> = {},
 ): Promise<ManagedAgentReport> {
+  const d = { ...defaultSpawnAgentDeps, ...deps };
   const label = opts.label || defaultSpawnLabel();
   const agentId = opts.agentId || managedAgentId(config, opts.provider, label);
   const name = sessionName(config, opts.provider, label, opts.spawnRequestId ?? agentId);
@@ -22,21 +52,27 @@ export async function spawnAgent(
   if (!isWithinBaseDir(opts.cwd, config.baseDir)) {
     throw new Error(`cwd must be within base directory: ${config.baseDir}`);
   }
+  const existing = existingSpawnSession(opts, d);
+  if (existing) return existing;
 
-  const resolvedWorkspace = await resolveSpawnWorkspace({
+  const resolvedWorkspace = await d.resolveSpawnWorkspace({
     ...opts,
     label,
     workspaceSymlinks: opts.workspaceSymlinks,
     workspaceRoot: workspacesRoot(config.baseDir),
   });
+  if (resolvedWorkspace.reusedExisting) {
+    const existingAfterPrep = existingSpawnSession(opts, d);
+    if (existingAfterPrep) return existingAfterPrep;
+  }
   const spawnOpts = { ...opts, label, agentId, cwd: resolvedWorkspace.cwd, workspace: resolvedWorkspace.workspace };
 
   const command = buildRunnerCommand(spawnOpts, config);
 
-  ensureLogDir();
-  ensureRunnerInfoDir();
-  const logFile = logFilePath(name);
-  const runnerInfoFile = runnerInfoPath(name);
+  d.ensureLogDir();
+  d.ensureRunnerInfoDir();
+  const logFile = d.logFilePath(name);
+  const runnerInfoFile = d.runnerInfoPath(name);
   rmSync(runnerInfoFile, { force: true });
   const env = buildEnv({ ...spawnOpts, env: { ...(spawnOpts.env ?? {}), AGENT_RELAY_RUNNER_INFO_FILE: runnerInfoFile } }, config, logFile, name);
   const logFd = openSync(logFile, "w");
@@ -48,9 +84,9 @@ export async function spawnAgent(
 
   closeSync(logFd);
 
-  const runner = spawnRunner(name, command, spawnOpts.cwd, env, logFile);
+  const runner = d.spawnRunner(name, command, spawnOpts.cwd, env, logFile);
 
-  addSessionRecord({
+  d.addSessionRecord({
     name,
     pid: runner.pid,
     supervisor: runner.supervisor,
@@ -81,7 +117,7 @@ export async function spawnAgent(
     profile: spawnOpts.profile,
     workspaceMode: spawnOpts.workspaceMode, lifecycle: spawnOpts.lifecycle ?? "persistent",
     workspace: spawnOpts.workspace,
-    ...sessionReportFields({ name, supervisor: runner.supervisor, runnerInfoFile, agentId, provider: spawnOpts.provider }),
+    ...d.sessionReportFields({ name, supervisor: runner.supervisor, runnerInfoFile, agentId, provider: spawnOpts.provider }),
     cwd: spawnOpts.cwd,
     label,
     approvalMode: spawnOpts.approvalMode || "guarded",
@@ -92,3 +128,33 @@ export async function spawnAgent(
     startedAt: Date.now(),
   };
 }
+
+function existingSpawnSession(opts: SpawnOptions, deps: Pick<SpawnAgentDeps, "findSessionRecord" | "sessionRecordLiveness" | "currentSessionPid" | "sessionReportFields">): ManagedAgentReport | undefined {
+  if (!opts.spawnRequestId) return undefined;
+  const record = deps.findSessionRecord({ spawnRequestId: opts.spawnRequestId, policyName: opts.policyName });
+  if (!record) return undefined;
+  const liveness = deps.sessionRecordLiveness(record);
+  if (liveness === "dead") return undefined;
+  const pid = deps.currentSessionPid(record);
+  return {
+    agentId: record.agentId,
+    provider: record.provider as ManagedAgentReport["provider"],
+    model: record.model,
+    effort: record.effort,
+    profile: record.profile,
+    workspaceMode: record.workspaceMode,
+    lifecycle: record.lifecycle ?? "persistent",
+    workspace: record.workspace,
+    ...deps.sessionReportFields(record),
+    cwd: record.cwd,
+    label: record.label,
+    approvalMode: record.approvalMode || "guarded",
+    policyName: record.policyName,
+    spawnRequestId: record.spawnRequestId,
+    automationRunId: record.automationRunId,
+    pid,
+    startedAt: record.startedAt,
+  };
+}
+
+export type { SpawnAgentDeps };

package/src/workspace-probe/probe.ts

@@ -91,9 +91,24 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
     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);
+    const existing = existingRegisteredWorktree(repoRoot, worktreePath);
+    if (existing) {
+      return existingWorkspaceResolution({
+        id,
+        repoRoot,
+        sourceCwd,
+        worktreePath,
+        branch: existing.branch,
+        baseRef: resume.branch,
+        baseSha,
+        requestedMode,
+        probe,
+      });
+    }
+
+    const branch = await availableBranch(repoRoot, branchName(input, id));
     mkdirSync(join(worktreePath, ".."), { recursive: true });
     requireGit(["worktree", "add", "-b", branch, worktreePath, baseSha], repoRoot);
     const deps = provisionWorkspaceDeps(repoRoot, worktreePath);
@@ -122,9 +137,24 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
   const repoRoot = probe.repoRoot;
   const baseRef = terminalBaseRef(repoRoot, probe.branch);
   const baseSha = probe.headSha ?? requireGit(["rev-parse", "HEAD"], repoRoot);
-  const branch = await availableBranch(repoRoot, branchName(input, id));
   const workspaceRoot = input.workspaceRoot ? resolve(input.workspaceRoot) : workspacesRoot(homedir());
   const worktreePath = join(workspaceRoot, repoSlug(repoRoot), id);
+  const existing = existingRegisteredWorktree(repoRoot, worktreePath);
+  if (existing) {
+    return existingWorkspaceResolution({
+      id,
+      repoRoot,
+      sourceCwd,
+      worktreePath,
+      branch: existing.branch,
+      baseRef,
+      baseSha,
+      requestedMode,
+      probe,
+    });
+  }
+
+  const branch = await availableBranch(repoRoot, branchName(input, id));
   mkdirSync(join(worktreePath, ".."), { recursive: true });
   requireGit(["worktree", "add", "-b", branch, worktreePath, baseSha], repoRoot);
 
@@ -156,3 +186,45 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
     },
   };
 }
+
+function existingRegisteredWorktree(repoRoot: string, worktreePath: string): { branch?: string } | undefined {
+  const resolvedPath = resolve(worktreePath);
+  if (!existsSync(resolvedPath)) return undefined;
+  const listed = git(["worktree", "list", "--porcelain"], repoRoot);
+  if (!listed.ok) return undefined;
+  const match = parseWorktrees(listed.stdout).find((worktree) => resolve(worktree.path) === resolvedPath);
+  if (!match) return undefined;
+  const topLevel = git(["rev-parse", "--show-toplevel"], resolvedPath);
+  if (!topLevel.ok || resolve(topLevel.stdout) !== resolvedPath) return undefined;
+  return { branch: match.branch };
+}
+
+function existingWorkspaceResolution(input: {
+  id: string;
+  repoRoot: string;
+  sourceCwd: string;
+  worktreePath: string;
+  branch?: string;
+  baseRef?: string;
+  baseSha?: string;
+  requestedMode: WorkspaceMode | "inherit";
+  probe: WorkspaceProbe;
+}): WorkspaceResolution {
+  return {
+    cwd: input.worktreePath,
+    reusedExisting: true,
+    workspace: {
+      id: input.id,
+      mode: "isolated",
+      requestedMode: input.requestedMode,
+      repoRoot: input.repoRoot,
+      sourceCwd: input.sourceCwd,
+      worktreePath: input.worktreePath,
+      ...(input.branch ? { branch: input.branch } : {}),
+      ...(input.baseRef ? { baseRef: input.baseRef } : {}),
+      ...(input.baseSha ? { baseSha: input.baseSha } : {}),
+      status: "active",
+      probe: input.probe,
+    },
+  };
+}

package/src/workspace-probe/types.ts

@@ -33,6 +33,7 @@ export interface WorkspaceResolutionInput {
 export interface WorkspaceResolution {
   cwd: string;
   workspace: WorkspaceMetadata;
+  reusedExisting?: boolean;
 }
 
 export interface WorkspaceMergeInput {