borgmcp 2.14.2 → 2.16.0

package/src/assimilate-cmd.ts

@@ -23,6 +23,7 @@ import { codexBorgSessionConfigArgs } from './launch-gate.js';
 import {
   codexAgentKindConfigArgs,
   codexRemoteWakeConfigArgs,
+  codexStateRootConfigArgs,
   withAgentRuntimeEnv,
 } from './agent-runtime.js';
 import type { BorgCli } from './cubes.js';
@@ -74,6 +75,14 @@ import type { SeatBinding, BindPendingSeatOutcome } from './seats.js';
 import { createHash } from 'node:crypto';
 import { buildOpenCodeLaunchArgs, type LaunchApprovalDecision } from './cli-tool-approval.js';
 import { resolveWorkingRepo, type WorkingRepo } from './working-repo.js';
+import {
+  BORG_LAUNCH_CLI_ENV,
+  BORG_LAUNCH_SCRATCH_ENV,
+  BORG_LAUNCH_WORKTREE_ENV,
+  codexLaunchDirectoryArgs,
+  scratchRootForSeat,
+  type LaunchAccessPaths,
+} from './launch-access.js';
 import type {
   AssociateRepositoryCubeResponse,
   CreateCubeRepository,
@@ -287,6 +296,12 @@ export interface AssimilateDeps {
   // launch root's .claude/settings.local.json (project-local; idempotent).
   // Real wiring = config-utils addProjectSessionStartHook.
   installProjectSessionHook: (projectRoot: string) => void;
+  /** Pre-authorize only the launched seat's worktree + scratch paths. */
+  provisionLaunchAccess?: (
+    cli: BorgCli,
+    projectRoot: string,
+    paths: LaunchAccessPaths,
+  ) => void;
 
   /** gh#27: optional test seam — when set, selectAssimilationAuthority uses
    *  this instead of prompting/failing. Not wired in production. */
@@ -373,6 +388,8 @@ export interface AssimilateDeps {
   // on healthy hosts; degraded-path surfaces a stderr warning and
   // still launches claude (never blocks).
   probeMcpReady: () => Promise<boolean>;
+  /** Save the resolved CLI for a newly-created sibling worktree. */
+  setCliPreferenceForWorktree: (cli: BorgCli, worktree: string) => Promise<void>;
   resolveCli: (explicit?: BorgCli) => Promise<BorgCli>;
   prepareCodexRemoteLaunch: () => Promise<CodexRemoteLaunch>;
   setCodexWakeTarget: (cubeId: string, droneId: string, target: { threadId: string; socketPath: string }) => Promise<void>;
@@ -693,13 +710,10 @@ export async function runAssimilate(
 ): Promise<number> {
   const mode = args.mode ?? 'assimilate';
   // ----- Input validation (before any subprocess work) -----
-  if (args.role !== undefined) {
-    const v = validateName(args.role);
-    if (!v.ok) {
-      deps.stderr(v.error + '\n');
-      return 1;
-    }
-  }
+  // A role is a lookup key, not a path component. matchRoleByName() below
+  // applies the shared roleSlug() normalization, so displayed names such as
+  // "Builder" and "Code Reviewer" must reach that resolver. Keep the strict
+  // identifier validator for worktree names, which do become path components.
   if (args.flags.worktree !== undefined) {
     const v = validateName(args.flags.worktree);
     if (!v.ok) {
@@ -1807,6 +1821,22 @@ export async function runAssimilate(
     spawnedWorktreePath = deps.cwd();
   }
 
+  // ----- Step 7b: provision launch access before persisting/launching -----
+  // The launched process gets exactly its current worktree plus a stable,
+  // disposable per-seat scratch root. Provision this before FINALIZE so a
+  // failed config write cannot produce a saved seat that launches without
+  // its promised path grants.
+  const agentCwd = deps.cwd(); // post-chdir if step 3 spawned a worktree
+  const seatWorktree = deps.findProjectRoot(agentCwd);
+  const monitorStateRoot = monitorStateRootForWorktree(seatWorktree);
+  const scratchRoot = scratchRootForSeat(deps.homedir(), result.drone_label, result.drone_id);
+  const launchAccessPaths: LaunchAccessPaths = {
+    // Access is granted at the repository root even when the harness starts in
+    // a nested package. The launch cwd remains the operator's chosen subdir.
+    worktree: seatWorktree,
+    scratch: scratchRoot,
+  };
+
   // ----- Step 8: persist the binding (narrow rollback — worktree exists if spawned) -----
   const activeCube: ActiveCube = {
     cubeId: result.cube_id,
@@ -1836,6 +1866,37 @@ export async function runAssimilate(
     }
   };
 
+  // CLI resolution happens before the server attach because agent_kind is part
+  // of that request. The resolver therefore saved the preference against the
+  // invoking checkout. Once a sibling exists, save the same choice under its
+  // own project key so a later --here launch in that worktree can read it.
+  if (spawnedWorktreePath) {
+    try {
+      await deps.setCliPreferenceForWorktree(cli, spawnedWorktreePath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      deps.stderr(
+        `Borg could not save the ${cli} preference for sibling worktree ${spawnedWorktreePath}: ${message}. ` +
+          'The worktree was removed; correct the local configuration and retry.\n',
+      );
+      rollbackWorktree();
+      return 1;
+    }
+  }
+
+  try {
+    deps.mkdirp(scratchRoot);
+    deps.provisionLaunchAccess?.(cli, seatWorktree, launchAccessPaths);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    deps.stderr(
+      `Borg could not pre-authorize the ${cli} launch paths: ${message}. ` +
+      'No agent was launched; correct the local configuration and retry.\n',
+    );
+    rollbackWorktree();
+    return 1;
+  }
+
   // Local-server authority: drive the COMPOSITE cube-owned FINALIZE (Race 2).
   // The cube lock is held OUTER across revalidate → binding-write → activate; the
   // typed expectation is declared HERE at the orchestration layer (reattach =
@@ -1945,13 +2006,6 @@ export async function runAssimilate(
     }
   }
 
-  // The worktree, not a reminted drone UUID, is the stable local seat identity
-  // for monitor runtime state. Capture it once before the lazy GC and launch
-  // paths so both use the exact same explicit root.
-  const agentCwd = deps.cwd(); // post-chdir if step 3 spawned a worktree
-  const seatWorktree = deps.findProjectRoot(agentCwd);
-  const monitorStateRoot = monitorStateRootForWorktree(seatWorktree);
-
   // gh#793: best-effort GC of orphaned inbox files (evicted/dead drones) in the
   // cube just joined — lazy-on-assimilate, no cron/new command. NEVER blocks or
   // fails the assimilate (whole call swallowed). Local-only signal (CubeDetail
@@ -2082,6 +2136,9 @@ export async function runAssimilate(
     ...(withAgentRuntimeEnv(process.env, cli) as Record<string, string>),
     ...modelEnv.set,
     BORG_SESSION: '1',
+    [BORG_LAUNCH_CLI_ENV]: cli,
+    [BORG_LAUNCH_WORKTREE_ENV]: seatWorktree,
+    [BORG_LAUNCH_SCRATCH_ENV]: scratchRoot,
   };
   if (cli === 'opencode' && launchApproval.openCodePermission) {
     childEnv.OPENCODE_PERMISSION = launchApproval.openCodePermission;
@@ -2127,10 +2184,12 @@ export async function runAssimilate(
     // off when no socket is available, overriding legacy static configs that
     // formerly used this transport marker as Codex identity.
     launchArgs = [
+      ...codexLaunchDirectoryArgs(launchAccessPaths),
       ...launchApproval.codexArgs,
       ...codexBorgSessionConfigArgs(),
       ...codexAgentKindConfigArgs(),
       ...codexRemoteWakeConfigArgs(codexSocketPath !== null),
+      ...codexStateRootConfigArgs(),
       ...remoteArgs,
       ...withCodexCwdArg(launchArgs, agentCwd),
     ];

package/src/assimilate-deps.ts

@@ -11,7 +11,7 @@
 import { spawnSync, spawn as spawnChild } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { existsSync, mkdirSync } from 'node:fs';
-import { hostname as osHostname, homedir as osHomedir } from 'node:os';
+import { hostname as osHostname } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import prompts from 'prompts';
 import { readinessProbeEnv } from './readiness-probe.js';
@@ -60,9 +60,16 @@ import {
   hasPersistedActiveCube as cubesHasPersistedActive,
   setActiveCube as cubesSetActive,
   inboxPathForDrone,
+  setProjectCliPreference,
   setCodexWakeTarget,
 } from './cubes.js';
-import { addProjectSessionStartHook } from './config-utils.js';
+import {
+  addClaudeLaunchAccess,
+  addCodexForeignPathReminderHook,
+  addOpenCodeLaunchAccess,
+  addProjectSessionStartHook,
+} from './config-utils.js';
+import type { LaunchAccessPaths } from './launch-access.js';
 import { findPendingServerEnrollment } from './config.js';
 import { setTerminalTitle as setTitle } from './terminal-title.js';
 import { defaultCliChoiceDeps, resolveCliChoice } from './cli-platform.js';
@@ -77,6 +84,7 @@ import {
   saveRepositoryAssociation,
 } from './repository-identity.js';
 import { PromptInterruptedError } from './repository-cube-init.js';
+import { borgHomeRoot } from './private-root.js';
 
 /**
  * Wraps the readline question operation with the production interruption
@@ -126,7 +134,7 @@ export function buildDefaultAssimilateDeps(
     // gh#556 Part 1: ~/.borg/worktrees relocation. homedir seams $HOME;
     // mkdirp is a plain recursive create (NO chmod of existing parents — the
     // ~/.borg credentials file's perms stay untouched).
-    homedir: () => osHomedir(),
+    homedir: () => borgHomeRoot(),
     mkdirp: (dir) => mkdirSync(dir, { recursive: true }),
     preparePrivateRoot: () => ensurePrivateBorgConfigRoot(),
     exec: (cmd, args, cwd, env) =>
@@ -235,6 +243,17 @@ export function buildDefaultAssimilateDeps(
     installProjectSessionHook: (projectRoot) => {
       addProjectSessionStartHook(projectRoot);
     },
+    provisionLaunchAccess: (cli, projectRoot, paths: LaunchAccessPaths) => {
+      if (cli === 'claude') {
+        addClaudeLaunchAccess(projectRoot, paths);
+      } else if (cli === 'codex') {
+        // Codex receives the path grant on the launch command itself. Its
+        // native PreToolUse hook is global but reads this launch's scoped env.
+        addCodexForeignPathReminderHook();
+      } else {
+        addOpenCodeLaunchAccess(projectRoot, paths);
+      }
+    },
 
     // #1015: discovery is advisory but still verifies the server-owned CA.
     detectLocalServer: async () =>
@@ -557,6 +576,7 @@ export function buildDefaultAssimilateDeps(
         }
       }, () => process.stdin.isTTY === true)
     ),
+    setCliPreferenceForWorktree: (cli, worktree) => setProjectCliPreference(cli, worktree),
     prepareCodexRemoteLaunch: () => prepareCodexRemoteLaunch(defaultCodexRemoteDeps()),
     setCodexWakeTarget,
     findLoadedCodexThread,

package/src/bare-launch-menu.ts

@@ -39,6 +39,23 @@ export interface LaunchMenuInputs {
   hasLaunchAllTargets: boolean;
 }
 
+/**
+ * Resolve and configure the CLI that will actually launch.
+ *
+ * This callback deliberately runs after the one-shot menu choice. A bare
+ * launch may resolve one default CLI first and then launch a different
+ * installed CLI for this invocation; only the final CLI may be self-healed.
+ */
+export function configureSelectedLaunchCli(
+  defaultCli: BorgCli,
+  action: LaunchMenuAction | undefined,
+  configure: (cli: BorgCli) => void,
+): BorgCli {
+  const cli = action?.kind === 'launch' ? action.cli : defaultCli;
+  configure(cli);
+  return cli;
+}
+
 const PRETTY: Record<BorgCli, string> = { claude: 'Claude', codex: 'Codex', opencode: 'OpenCode' };
 
 /**

package/src/claude.ts

@@ -24,7 +24,7 @@ import { basename } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
-import { findProjectRoot, getActiveCube, inboxPathForDrone, setCodexWakeTarget, pruneDeadCodexWakeTargets } from './cubes.js';
+import { findProjectRoot, getActiveCube, inboxPathForDrone, setCodexWakeTarget, pruneDeadCodexWakeTargets, type BorgCli } from './cubes.js';
 import { monitorStateRootForWorktree } from './inbox-monitor.js';
 import { formatSeatReattachRefusal, inspectLiveInboxMonitor } from './seat-reattach-guard.js';
 import { handleVersionFlag, getPackageVersion } from './version.js';
@@ -48,10 +48,12 @@ import { runLaunchAll } from './launch-all-cmd.js';
 import { buildDefaultLaunchAllDeps } from './launch-all-deps.js';
 import { discoverDroneCandidates } from './launch-all-discovery.js';
 import {
+  configureSelectedLaunchCli,
   explicitCliLaunchHint,
   runBareLaunchMenu,
   shouldResolveExplicitCliLaunchHintTargets,
   shouldShowLaunchMenu,
+  type LaunchMenuAction,
 } from './bare-launch-menu.js';
 import { setTerminalTitle } from './terminal-title.js';
 import { initConsolePrefix, consolePrefix } from './console-prefix.js';
@@ -62,6 +64,7 @@ import {
   BORG_CODEX_REMOTE_WAKE_ENV,
   codexAgentKindConfigArgs,
   codexRemoteWakeConfigArgs,
+  codexStateRootConfigArgs,
   withAgentRuntimeEnv,
 } from './agent-runtime.js';
 import { findLoadedCodexThread } from './codex-app-server.js';
@@ -80,6 +83,7 @@ import {
   removeSessionStartHook,
 } from './config-utils.js';
 import { ensureCliMcpConfigured } from './ensure-mcp-config.js';
+import { configureResolvedCli } from './resolved-cli-config.js';
 import { installBorgPlugin } from './opencode-plugin.js';
 import { allocateOpenCodePort, connectOpenCodeDrone, createOpenCodeLaunchKickoff, injectInitialKickoff, openCodeLaunchBinding } from './opencode-drone.js';
 import { buildOpenCodeLaunchArgs, defaultApprovalIo, resolveLaunchBorgApprovals } from './cli-tool-approval.js';
@@ -321,7 +325,7 @@ async function main() {
     parsedCli.cli,
     defaultCliChoiceDeps(prompt, () => process.stdin.isTTY === true)
   );
-  ensureDetectedCliConfigured();
+  let launchAction: LaunchMenuAction | undefined;
 
   // Active cube for this directory — needed for the launch menu's option-3
   // availability, the terminal title, and the inbox-Monitor clause below.
@@ -382,9 +386,13 @@ async function main() {
     // option 1 → configured default; option 2 → the other agent, ONE-SHOT
     // (we deliberately do NOT call setProjectCliPreference — the saved
     // preference is changed only via `borg --cli <agent>`).
-    cli = action.cli;
+    launchAction = action;
   }
 
+  // Configure only the CLI that will actually launch. This must follow the
+  // one-shot menu: the resolved default can differ from the menu selection.
+  cli = configureSelectedLaunchCli(cli, launchAction, ensureResolvedCliConfigured);
+
   if (active && !parsedCli.force) {
     const inboxPath = inboxPathForDrone(active.cubeId, active.droneId);
     const stateRoot = monitorStateRootForWorktree(findProjectRoot(process.cwd()));
@@ -531,6 +539,7 @@ async function main() {
       ...codexBorgSessionConfigArgs(),
       ...codexAgentKindConfigArgs(),
       ...codexRemoteWakeConfigArgs(codexSocketPath !== null),
+      ...codexStateRootConfigArgs(),
       ...remoteArgs,
       ...withCodexCwdArg([...passthroughArgs, kickoff], process.cwd()),
     ];
@@ -614,40 +623,25 @@ async function main() {
   });
 }
 
-function ensureDetectedCliConfigured(): void {
-  const found = detectCliAvailability();
-  if (found.claude) {
-    try {
-      ensureCliMcpConfigured('claude');
-      // gh#673 P2 (WI-1): the orientation hook lives PROJECT-LOCAL in
-      // <root>/.claude/settings.local.json — ensured on every bare
-      // `borg` launch so pre-P2 worktrees self-heal. The legacy GLOBAL
-      // hook is then removed: safe because this ensure precedes every
-      // borg-launched agent spawn (other projects get their local hook
-      // at their own next launch/assimilate), and P1's BORG_SESSION
-      // gate already no-ops the global hook in non-borg sessions.
-      addProjectSessionStartHook(findProjectRoot(process.cwd()));
-      removeSessionStartHook();
-      addUserPromptSubmitHook();
-    } catch (err: any) {
-      console.error(`${consolePrefix()}${chalk.yellow(`warning: Claude Code integration check failed: ${err?.message ?? err}`)}`);
-    }
-  }
-  if (found.codex) {
-    try {
-      ensureCliMcpConfigured('codex');
-      addCodexSessionStartHook();
-      addCodexUserPromptSubmitHook();
-    } catch (err: any) {
-      console.error(`${consolePrefix()}${chalk.yellow(`warning: Codex integration check failed: ${err?.message ?? err}`)}`);
-    }
-  }
-  if (found.opencode) {
-    try {
-      ensureCliMcpConfigured('opencode');
-    } catch (err: any) {
-      console.error(`${consolePrefix()}${chalk.yellow(`warning: OpenCode integration check failed: ${err?.message ?? err}`)}`);
-    }
+function ensureResolvedCliConfigured(cli: BorgCli): void {
+  const label = cli === 'claude' ? 'Claude Code' : cli === 'codex' ? 'Codex' : 'OpenCode';
+  try {
+    configureResolvedCli(cli, {
+      ensureMcp: ensureCliMcpConfigured,
+      addClaudeProjectSessionStartHook: () => {
+        // gh#673 P2 (WI-1): the orientation hook lives PROJECT-LOCAL in
+        // <root>/.claude/settings.local.json — ensured on every bare
+        // `borg` launch so pre-P2 worktrees self-heal. The legacy GLOBAL
+        // hook is then removed after the local hook is in place.
+        addProjectSessionStartHook(findProjectRoot(process.cwd()));
+      },
+      removeClaudeGlobalSessionStartHook: removeSessionStartHook,
+      addClaudeUserPromptSubmitHook: addUserPromptSubmitHook,
+      addCodexSessionStartHook,
+      addCodexUserPromptSubmitHook,
+    });
+  } catch (err: any) {
+    console.error(`${consolePrefix()}${chalk.yellow(`warning: ${label} integration check failed: ${err?.message ?? err}`)}`);
   }
 }
 

package/src/cleanup-cmd.ts

@@ -36,7 +36,6 @@
 import { spawnSync } from 'node:child_process';
 import { realpathSync } from 'node:fs';
 import { sep, basename, dirname } from 'node:path';
-import { homedir } from 'node:os';
 import chalk from 'chalk';
 import {
   classifyDirty,
@@ -51,6 +50,7 @@ import {
   type ActiveCube,
 } from './cubes.js';
 import { defaultProbeSeat, type SeatStatus } from './seat-probe.js';
+import { borgHomeRoot } from './private-root.js';
 
 // ------------------------------------------------------------------
 // Types
@@ -208,7 +208,7 @@ const defaultDeps: Required<CleanupDeps> = {
     const r = spawnSync(cmd, args, { cwd, encoding: 'utf-8' });
     return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
   },
-  homeDir: () => homedir(),
+  homeDir: () => borgHomeRoot(),
   cwd: () => process.cwd(),
   listSeats: () => readAllProjectIdentities(),
   probeSeat: defaultProbeSeat,

package/src/cli-tool-approval.ts

@@ -1,8 +1,9 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { chmod, copyFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
+import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import type { BorgCli } from './cubes.js';
+import { borgHomeRoot } from './private-root.js';
 
 /**
  * Client #20: the narrow coordination surface a borg-launched agent needs
@@ -360,7 +361,7 @@ async function withNativeCodexProfileLayer<T>(
   env: NodeJS.ProcessEnv,
   query: (profileCwd: string, trustOverride: string) => Promise<CodexConfigSnapshot>
 ): Promise<T> {
-  const codexHome = resolve(env.CODEX_HOME || join(homedir(), '.codex'));
+  const codexHome = resolve(env.CODEX_HOME || join(borgHomeRoot(), '.codex'));
   const profilePath = resolve(codexHome, `${profile}.config.toml`);
   if (dirname(profilePath) !== codexHome) {
     throw new Error('Codex profile path was invalid');

package/src/codex-remote.ts

@@ -1,5 +1,4 @@
 import { mkdirSync, chmodSync, readdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { spawn } from 'node:child_process';
@@ -11,7 +10,9 @@ import {
   BORG_CODEX_REMOTE_WAKE_ENV,
   codexAgentKindConfigArgs,
   codexRemoteWakeConfigArgs,
+  codexStateRootConfigArgs,
 } from './agent-runtime.js';
+import { borgConfigRoot } from './private-root.js';
 
 /**
  * gh#528 — npm-managed Codex remote-wake.
@@ -75,7 +76,7 @@ export interface PrepareCodexRemoteDeps {
   isAlive?: (pid: number) => boolean;
 }
 
-export const DEFAULT_CODEX_REMOTE_DIR = join(homedir(), '.config', 'borgmcp', 'codex-remote');
+export const DEFAULT_CODEX_REMOTE_DIR = join(borgConfigRoot(), 'codex-remote');
 const DEFAULT_CODEX_REMOTE_READY_TIMEOUT_MS = 30_000;
 const MAX_CODEX_APP_SERVER_STDERR_CHARS = 16_384;
 
@@ -426,6 +427,7 @@ export function defaultCodexRemoteDeps(): Pick<
           ...codexBorgSessionConfigArgs(),
           ...codexAgentKindConfigArgs(),
           ...codexRemoteWakeConfigArgs(),
+          ...codexStateRootConfigArgs(),
           ...codexAppServerSocketConfigArgs(socketPath),
           '--listen',
           `unix://${socketPath}`,