forge-workflow 0.1.0-beta.4 → 0.1.0-beta.6

package/lib/commands/worktree.js

@@ -3,7 +3,12 @@
 const { execFileSync, spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
-const { detectDefaultBranch } = require('../beads-sync-scaffold');
+const { detectDefaultBranch } = require('../git-defaults');
+const {
+  resolveRepoRelativePath,
+  assertNoAncestorSymlinkEscape,
+  assertNoSymlinkEscape,
+} = require('../protected-state-surfaces');
 
 /**
  * Forge Worktree Command
@@ -42,12 +47,13 @@ function detectPackageManager(projectRoot, fsApi) {
 /**
  * Check if a git branch already exists.
  * @param {string} branchName - Branch name to check
+ * @param {string} projectRoot - Repo root to run git in
  * @param {Function} runFile - execFileSync function (for DI)
  * @returns {boolean}
  */
-function branchExists(branchName, runFile) {
+function branchExists(branchName, projectRoot, runFile) {
   try {
-    const output = runFile('git', ['branch', '--list', branchName], { stdio: 'pipe' });
+    const output = runFile('git', ['-C', projectRoot, 'branch', '--list', branchName], { stdio: 'pipe' });
     return output.toString().trim().length > 0;
   } catch (_err) { /* intentional: branch doesn't exist */ // NOSONAR S2486
     return false;
@@ -99,35 +105,226 @@ function isLinkPermissionError(error) {
   return ['EPERM', 'EACCES', 'ENOSYS', 'UV_EPERM'].includes(error && error.code);
 }
 
+// Yarn is probe-less here: a Plug'n'Play install produces no node_modules tree to
+// inspect, and `yarn check` was removed in Berry, so there is nothing to verify.
+const PROBE_LESS_MANAGERS = new Set(['yarn']);
+
+function samePath(left, right) {
+  return path.relative(left, right) === '';
+}
+
 /**
- * Run package install in the new worktree if a package manager is detected, and
- * SURFACE failures (spawn error or non-zero exit) instead of swallowing them.
- * @param {string} worktreePath - Absolute path to the new worktree
- * @param {string} projectRoot - Absolute path to the project root
- * @param {Function} spawnFn - spawnSync-compatible function
+ * Direct dependencies the root and its workspaces declare. Optional/peer deps
+ * are excluded — they may legitimately be absent. Workspace discovery fails
+ * closed so an incomplete manifest set cannot prove an install complete.
+ * @param {string} worktreePath - Absolute path to the worktree
  * @param {object} fsApi - fs module (for DI)
- * @returns {{ linked: boolean, installed: boolean }}
- * @throws {Error} when the install cannot be spawned or exits non-zero.
+ * @returns {Array<{dir: string, name: string, workspaceDir: string|null}>} Declaring directory and package name
  */
-function runInstall(worktreePath, projectRoot, spawnFn, fsApi) {
-  const pkgManager = detectPackageManager(projectRoot, fsApi);
-  if (!pkgManager) return { linked: false, installed: false };
+function declaredDependencies(worktreePath, fsApi) {
+  let rootPkg;
+  try {
+    rootPkg = JSON.parse(fsApi.readFileSync(path.join(worktreePath, 'package.json'), 'utf8'));
+  } catch (error) {
+    throw new Error(`Cannot verify dependencies: unreadable worktree package.json: ${error.message}`);
+  }
+
+  let workspacePatterns = [];
+  if (rootPkg.workspaces != null) {
+    workspacePatterns = Array.isArray(rootPkg.workspaces)
+      ? rootPkg.workspaces
+      : rootPkg.workspaces.packages;
+    if (!Array.isArray(workspacePatterns)) {
+      throw new Error('Cannot verify dependencies: workspaces must be an array or an object with a packages array');
+    }
+  }
+
+  if (workspacePatterns.length && typeof fsApi.globSync !== 'function') {
+    throw new Error('Cannot verify dependencies: this runtime does not provide workspace glob support');
+  }
+
+  const manifestPaths = new Set();
+  for (const rawPattern of workspacePatterns) {
+    if (typeof rawPattern !== 'string' || !rawPattern.trim()) {
+      throw new Error(`Cannot verify dependencies: invalid workspace pattern ${JSON.stringify(rawPattern)}`);
+    }
+    const exclude = rawPattern.startsWith('!');
+    const pattern = (exclude ? rawPattern.slice(1) : rawPattern).replace(/\\/g, '/').replace(/\/+$/, '');
+    const resolvedPattern = resolveRepoRelativePath(worktreePath, pattern);
+    if (!pattern || pattern.includes('\0') || path.isAbsolute(pattern) || !resolvedPattern.insideRoot) {
+      throw new Error(`Cannot verify dependencies: workspace pattern resolves outside the worktree: ${rawPattern}`);
+    }
 
+    let matches;
+    try {
+      matches = fsApi.globSync(`${pattern}/package.json`, {
+        cwd: worktreePath,
+        exclude: candidate => String(candidate).split(/[\\/]/).includes('node_modules'),
+      });
+    } catch (error) {
+      throw new Error(`Cannot verify dependencies: workspace glob failed for ${rawPattern}: ${error.message}`);
+    }
+    for (const match of matches) {
+      const resolved = resolveRepoRelativePath(worktreePath, String(match));
+      if (!resolved.insideRoot) {
+        throw new Error(`Cannot verify dependencies: workspace glob resolved outside the worktree: ${match}`);
+      }
+      const existing = [...manifestPaths].find(manifestPath => samePath(manifestPath, resolved.target));
+      if (exclude && existing) manifestPaths.delete(existing);
+      else if (!exclude && !existing) manifestPaths.add(resolved.target);
+    }
+  }
+
+  const manifests = [{ dir: worktreePath, pkg: rootPkg }];
+  for (const manifestPath of manifestPaths) {
+    try {
+      manifests.push({
+        dir: path.dirname(manifestPath),
+        pkg: JSON.parse(fsApi.readFileSync(manifestPath, 'utf8')),
+      });
+    } catch (error) {
+      if (error && ['ENOENT', 'ENOTDIR'].includes(error.code)) continue;
+      throw new Error(`Cannot verify dependencies: unreadable workspace manifest ${manifestPath}: ${error.message}`);
+    }
+  }
+
+  const workspaceDirs = new Map();
+  for (const { dir, pkg } of manifests.slice(1)) {
+    if (!pkg.name) continue;
+    if (workspaceDirs.has(pkg.name) && !samePath(workspaceDirs.get(pkg.name), dir)) {
+      throw new Error(`Cannot verify dependencies: duplicate workspace package name ${pkg.name}`);
+    }
+    workspaceDirs.set(pkg.name, dir);
+  }
+  return manifests.flatMap(({ dir, pkg }) => [
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}),
+  ].map(name => ({ dir, name, workspaceDir: workspaceDirs.get(name) || null })));
+}
+
+function dependencyCandidatePresent(candidate, workspaceDir, fsApi) {
+  if (!fsApi.existsSync(path.join(candidate, 'package.json'))) return false;
+  if (!workspaceDir) return true;
+  try {
+    return path.relative(fsApi.realpathSync(workspaceDir), fsApi.realpathSync(candidate)) === '';
+  } catch (_err) { /* intentional: an unresolvable workspace link is not installed */ // NOSONAR S2486
+    return false;
+  }
+}
+
+/**
+ * Verify the install actually landed: every declared direct dependency must be a
+ * real package in the worktree's node_modules.
+ *
+ * The package managers cannot answer this. `bun pm ls`, `bun list`, `bun pm why`
+ * and `bun install --dry-run` all read the LOCKFILE and exit 0 while packages are
+ * physically missing; `pnpm ls --depth=0` does the same; `bun -e require.resolve`
+ * is defeated by Bun's auto-install. Only `npm ls --depth=0` exits non-zero, so a
+ * filesystem check is the one probe that holds for every manager.
+ *
+ * @param {string} worktreePath - Absolute path to the worktree
+ * @param {object} fsApi - fs module (for DI)
+ * @param {string|null} pkgManager - Detected package manager
+ * @returns {boolean} true when nothing is missing
+ */
+function dependenciesPresent(worktreePath, fsApi, pkgManager) {
+  if (!pkgManager) return true;
+  const deps = declaredDependencies(worktreePath, fsApi);
+  return deps.every(({ dir, name, workspaceDir }) => {
+    const localPackage = path.join(dir, 'node_modules', name);
+    if (fsApi.existsSync(localPackage)) {
+      return dependencyCandidatePresent(localPackage, workspaceDir, fsApi);
+    }
+
+    const rootPackage = path.join(worktreePath, 'node_modules', name);
+    if (dir === worktreePath || (pkgManager === 'bun' && !workspaceDir)) return false;
+    return dependencyCandidatePresent(rootPackage, workspaceDir, fsApi);
+  });
+}
+
+function detachModulesLink(modulesPath, fsApi) {
+  try {
+    if (!fsApi.lstatSync(modulesPath).isSymbolicLink()) return false;
+    fsApi.unlinkSync(modulesPath);
+    return true;
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+const STDERR_DETAIL_LIMIT = 400;
+
+/**
+ * The install's captured stderr, trimmed and bounded — stdio 'pipe' otherwise
+ * hides why the install failed.
+ * @param {object} result - spawnSync result
+ * @returns {string} A leading-newline detail block, or '' when there is nothing
+ */
+function stderrDetail(result) {
+  const text = result && result.stderr ? String(result.stderr).trim() : '';
+  if (!text) return '';
+  return `\n${text.length > STDERR_DETAIL_LIMIT ? `${text.slice(0, STDERR_DETAIL_LIMIT)}...` : text}`;
+}
+
+/**
+ * Spawn one install, surfacing spawn errors, kills, and non-zero exits.
+ * @param {string} pkgManager - Detected package manager command
+ * @param {string[]} args - Install args (e.g. ['install'] or ['install', '--force'])
+ * @param {string} worktreePath - cwd for the install
+ * @param {Function} spawnFn - spawnSync-compatible function
+ * @throws {Error} when the install cannot be spawned, is killed, or exits non-zero.
+ */
+function spawnInstall(pkgManager, args, worktreePath, spawnFn) {
   // shell:true on Windows: npm/pnpm/yarn are .cmd shims that cannot be spawned
   // directly (ENOENT / EINVAL). pkgManager comes from lockfile detection (fixed
   // set) and args are hardcoded, so no user input reaches the shell.
-  const result = spawnFn(pkgManager, ['install'], {
+  const result = spawnFn(pkgManager, args, {
     cwd: worktreePath,
     stdio: 'pipe',
     shell: process.platform === 'win32',
   });
+  const label = `${pkgManager} ${args.join(' ')}`;
   if (result && result.error) {
-    throw new Error(`Dependency install failed: could not run '${pkgManager} install' in ${worktreePath}: ${result.error.message}`);
+    throw new Error(`Dependency install failed: could not run '${label}' in ${worktreePath}: ${result.error.message}${stderrDetail(result)}`);
+  }
+  // A killed install (OOM, SIGTERM, CI cancel) reports status null with a signal
+  // set — never a non-zero code — so it must be checked on its own.
+  if (result && result.signal) {
+    throw new Error(`Dependency install failed: '${label}' was killed by ${result.signal} in ${worktreePath}${stderrDetail(result)}`);
   }
   if (result && typeof result.status === 'number' && result.status !== 0) {
-    throw new Error(`Dependency install failed: '${pkgManager} install' exited with code ${result.status} in ${worktreePath}`);
+    throw new Error(`Dependency install failed: '${label}' exited with code ${result.status} in ${worktreePath}${stderrDetail(result)}`);
   }
-  return { linked: false, installed: true };
+}
+
+/**
+ * Run package install in the new worktree if a package manager is detected, then
+ * VERIFY it. A stale shared store makes a plain install report "no changes" while
+ * leaving packages and binaries missing, so the exit code alone is not evidence —
+ * on a failed probe, reinstall once with --force and re-probe.
+ * @param {string} worktreePath - Absolute path to the new worktree
+ * @param {string} projectRoot - Absolute path to the project root
+ * @param {Function} spawnFn - spawnSync-compatible function
+ * @param {object} fsApi - fs module (for DI)
+ * @param {string|null} [pkgManager] - Detected package manager
+ * @returns {{ linked: boolean, installed: boolean, healed: boolean }}
+ * @throws {Error} when the install fails, or the tree is still broken after --force.
+ */
+function runInstall(worktreePath, projectRoot, spawnFn, fsApi, pkgManager = detectPackageManager(projectRoot, fsApi)) {
+  if (!pkgManager) return { linked: false, installed: false, healed: false };
+
+  spawnInstall(pkgManager, ['install'], worktreePath, spawnFn);
+
+  if (PROBE_LESS_MANAGERS.has(pkgManager) || dependenciesPresent(worktreePath, fsApi, pkgManager)) {
+    return { linked: false, installed: true, healed: false };
+  }
+
+  spawnInstall(pkgManager, ['install', '--force'], worktreePath, spawnFn);
+  if (!dependenciesPresent(worktreePath, fsApi, pkgManager)) {
+    throw new Error(`Dependency install could not be verified: packages are still missing in ${worktreePath} after '${pkgManager} install --force'. Run it manually there and inspect the output.`);
+  }
+  return { linked: false, installed: true, healed: true };
 }
 
 /**
@@ -142,30 +339,110 @@ function runInstall(worktreePath, projectRoot, spawnFn, fsApi) {
  * @param {Function} deps.spawnFn - spawnSync-compatible function
  * @param {object} deps.fsApi - fs module (for DI)
  * @param {string} deps.platform - process.platform value
- * @returns {{ linked: boolean, installed: boolean }}
+ * @returns {{ linked: boolean, installed: boolean, healed: boolean }}
  * @throws {Error} when linking fails for a non-privilege reason or install fails.
  */
 function setupWorktreeDeps(worktreePath, projectRoot, { spawnFn, fsApi, platform }) {
   const srcModules = path.join(projectRoot, 'node_modules');
   const destModules = path.join(worktreePath, 'node_modules');
+  const pkgManager = detectPackageManager(projectRoot, fsApi);
+
+  // Keep the zero-install fast path only when root and workspace dependencies
+  // are complete; Bun's isolated linker keeps workspace packages below each workspace.
+  if (fsApi.existsSync(destModules)) {
+    if (dependenciesPresent(worktreePath, fsApi, pkgManager)) return { linked: false, installed: false, healed: false };
+    detachModulesLink(destModules, fsApi);
+    return runInstall(worktreePath, projectRoot, spawnFn, fsApi, pkgManager);
+  }
 
-  // Already populated (e.g. git checkout carried it) — nothing to do.
-  if (fsApi.existsSync(destModules)) return { linked: false, installed: false };
+  // existsSync follows links, so remove a dangling directory entry before
+  // either replacing it with the shared install or installing in its place.
+  detachModulesLink(destModules, fsApi);
 
   // Fast path: link to the shared install when the main repo has one.
   if (fsApi.existsSync(srcModules)) {
     const linkType = platform === 'win32' ? 'junction' : 'dir';
     try {
       fsApi.symlinkSync(srcModules, destModules, linkType);
-      return { linked: true, installed: false };
     } catch (error) {
       // Degrade to a real install only when the link was refused for lack of
       // privilege/support; any other failure is surfaced to the caller.
       if (!isLinkPermissionError(error)) throw error;
+      return runInstall(worktreePath, projectRoot, spawnFn, fsApi, pkgManager);
     }
+    if (dependenciesPresent(worktreePath, fsApi, pkgManager)) {
+      return { linked: true, installed: false, healed: false };
+    }
+    fsApi.unlinkSync(destModules);
+  }
+
+  return runInstall(worktreePath, projectRoot, spawnFn, fsApi, pkgManager);
+}
+
+function readExistingWorktreeLinkage(driver, worktreePath, reuse) {
+  if (!reuse || !driver || typeof driver.getWorktreeLinkage !== 'function') return null;
+  return driver.getWorktreeLinkage({ path: worktreePath }) || null;
+}
+
+function detectLinkageConflict({ projectRoot, existing, issueId, workFolder, reuse }) {
+  if (!reuse || !existing) return null;
+  const existingIssue = existing.issue_id || null;
+  const existingFolder = existing.work_folder || null;
+  const folderChanged = workFolder && existingFolder
+    && path.resolve(projectRoot, workFolder) !== path.resolve(projectRoot, existingFolder);
+  if (!((issueId && existingIssue && issueId !== existingIssue) || folderChanged)) return null;
+  return {
+    issueId: issueId || existingIssue,
+    workFolder: workFolder || existingFolder,
+    reason: 'worktree linkage mismatch; existing issue/work-folder was not changed',
+    conflict: true,
+  };
+}
+
+function isAbsoluteWorkFolder(workFolder) {
+  return path.isAbsolute(workFolder) || path.posix.isAbsolute(workFolder) || path.win32.isAbsolute(workFolder);
+}
+
+function markerPathConflict(reason) {
+  return { conflict: true, reason: `worktree linkage marker path rejected: ${reason}` };
+}
+
+function validateMarkerTarget(projectRoot, workFolder, fsApi) {
+  if (!workFolder) return null;
+  if (isAbsoluteWorkFolder(workFolder)) return markerPathConflict('work-folder must be repo-relative');
+
+  const resolved = resolveRepoRelativePath(projectRoot, workFolder);
+  if (!resolved.insideRoot) return markerPathConflict('work-folder escapes project root');
+  const ancestorEscape = assertNoAncestorSymlinkEscape(resolved.root, resolved.target);
+  if (ancestorEscape) return markerPathConflict(ancestorEscape.reason);
+
+  const statSync = fsApi.statSync || fs.statSync;
+  const folderStat = fsApi.existsSync(resolved.target) ? statSync.call(fsApi, resolved.target) : null;
+  if (folderStat && !folderStat.isDirectory()) return markerPathConflict('work-folder is not a directory');
+  const markerPath = path.join(resolved.target, '.forge-issue');
+  const markerEscape = assertNoSymlinkEscape(resolved.root, markerPath);
+  if (markerEscape) {
+    return markerPathConflict(markerEscape.reason);
   }
+  return { folderAbs: resolved.target, markerPath, folderExists: Boolean(folderStat) };
+}
 
-  return runInstall(worktreePath, projectRoot, spawnFn, fsApi);
+function reconcileIssueMarker({ target, linkedIssue, linkedFolder, fsApi }) {
+  if (!target || !linkedIssue || !target.folderExists) return null;
+  let markerIssue = null;
+  try {
+    if (fsApi.existsSync(target.markerPath)) markerIssue = fsApi.readFileSync(target.markerPath, 'utf8').trim() || null;
+  } catch { /* unreadable marker — let the write below repair it */ }
+  if (markerIssue && markerIssue !== linkedIssue) {
+    return {
+      issueId: linkedIssue,
+      workFolder: linkedFolder,
+      reason: 'worktree linkage mismatch; existing issue marker was not changed',
+      conflict: true,
+    };
+  }
+  fsApi.writeFileSync(target.markerPath, `${linkedIssue}\n`, 'utf8');
+  return null;
 }
 
 /**
@@ -185,30 +462,44 @@ function setupWorktreeDeps(worktreePath, projectRoot, { spawnFn, fsApi, platform
  * @param {string|null} params.issueId
  * @param {string|null} params.workFolder - Repo-relative work-folder path.
  * @param {object} params.opts - DI options (may inject `_kernelDriver`, `_exec`, `_fs`).
+ * @param {boolean} [params.reuse] - Validate existing linkage before reconciling.
  * @returns {Promise<{registered: boolean, issueId: string|null, workFolder: string|null, reason?: string}>}
  */
-async function registerWorktreeLinkage({ projectRoot, worktreePath, branch, issueId, workFolder, opts }) {
+async function registerWorktreeLinkage({ projectRoot, worktreePath, branch, issueId, workFolder, opts, reuse = false }) {
   const runFile = opts._exec || execFileSync;
   const fsApi = opts._fs || fs;
   try {
-    // Drop the folder → issue marker first — deterministic even if the DB write fails.
-    if (workFolder && issueId) {
-      const folderAbs = path.resolve(projectRoot, workFolder);
-      fsApi.mkdirSync(folderAbs, { recursive: true });
-      fsApi.writeFileSync(path.join(folderAbs, '.forge-issue'), `${issueId}\n`, 'utf8');
-    }
-
     let driver = opts._kernelDriver;
     if (!driver) {
       // No reachable git repo → no shared Kernel; skip quietly (orientation still works
       // off the folder heuristic). Avoids spawning `git` in a non-repo directory.
-      if (!fsApi.existsSync(path.join(projectRoot, '.git'))) {
-        return { registered: false, issueId: issueId || null, workFolder: workFolder || null, reason: 'no git repository' };
+      if (fsApi.existsSync(path.join(projectRoot, '.git'))) {
+        // Lazy require: keep the worktree command light and avoid paying kernel setup
+        // when linkage is not needed. Migrated deps guarantee the 007 columns exist.
+        const { buildMigratedKernelIssueDeps } = require('../kernel/cli-broker-factory');
+        driver = (await buildMigratedKernelIssueDeps({ projectRoot })).kernelDriver;
       }
-      // Lazy require: keep the worktree command light and avoid paying kernel setup
-      // when linkage is not needed. Migrated deps guarantee the 007 columns exist.
-      const { buildMigratedKernelIssueDeps } = require('../kernel/cli-broker-factory');
-      driver = (await buildMigratedKernelIssueDeps({ projectRoot })).kernelDriver;
+    }
+
+    const existing = readExistingWorktreeLinkage(driver, worktreePath, reuse);
+    const linkageConflict = detectLinkageConflict({ projectRoot, existing, issueId, workFolder, reuse });
+    if (linkageConflict) return { registered: false, ...linkageConflict };
+
+    const existingIssue = existing?.issue_id || null;
+    const existingFolder = existing?.work_folder || null;
+    const linkedIssue = issueId || (reuse ? existingIssue : null);
+    const linkedFolder = workFolder || (reuse ? existingFolder : null);
+    const markerTarget = validateMarkerTarget(projectRoot, linkedFolder, fsApi);
+    if (markerTarget?.conflict) {
+      return { registered: false, issueId: linkedIssue || null, workFolder: linkedFolder || null, ...markerTarget };
+    }
+    const markerConflict = reconcileIssueMarker({ target: markerTarget, linkedIssue, linkedFolder, fsApi });
+    if (markerConflict) {
+      return { registered: false, ...markerConflict };
+    }
+
+    if (!driver) {
+      return { registered: false, issueId: linkedIssue || null, workFolder: linkedFolder || null, reason: 'no git repository' };
     }
 
     const { resolveGitCommonDir } = require('../kernel/broker');
@@ -219,13 +510,13 @@ async function registerWorktreeLinkage({ projectRoot, worktreePath, branch, issu
       path: worktreePath,
       branch,
       actor: process.env.FORGE_ACTOR || null,
-      issue_id: issueId || null,
-      work_folder: workFolder || null,
+      issue_id: linkedIssue || null,
+      work_folder: linkedFolder || null,
       registered_at: new Date().toISOString(),
       state: 'active',
     });
 
-    return { registered: true, issueId: issueId || null, workFolder: workFolder || null };
+    return { registered: true, issueId: linkedIssue || null, workFolder: linkedFolder || null };
   } catch (error) {
     // Non-fatal: keep the worktree usable. Only warn when the caller explicitly asked
     // for linkage (--issue/--work-folder); a plain `worktree create` stays quiet.
@@ -331,13 +622,30 @@ async function handleCreate(slug, flags, projectRoot, opts) {
       // A detached worktree reports the literal "HEAD" — don't persist that; keep branchName.
       if (head && head !== 'HEAD') existingBranch = head;
     } catch (_error) { /* not a resolvable worktree HEAD — fall back to branchName */ }
-    const linkage = await registerWorktreeLinkage({ projectRoot, worktreePath, branch: existingBranch, issueId, workFolder, opts });
+    const linkage = await registerWorktreeLinkage({ projectRoot, worktreePath, branch: existingBranch, issueId, workFolder, opts, reuse: true });
+    if (linkage.conflict) {
+      return { success: false, reused: true, error: linkage.reason, worktreePath, linkage };
+    }
+    let deps;
+    try {
+      deps = setupWorktreeDeps(worktreePath, projectRoot, {
+        spawnFn: runSpawn,
+        fsApi,
+        platform: opts._platform || process.platform,
+      });
+    } catch (error) {
+      return { success: false, reused: true, error: error.message, worktreePath, linkage };
+    }
     const backing = await autoFileBackingIssue({ projectRoot, worktreePath, branch: existingBranch, issueId, opts });
+    const healNote = deps.healed ? ' Healed dependencies (store was stale): reinstalled with --force.' : '';
     return {
       success: true,
       reused: true,
-      message: `Worktree already exists at ${worktreePath}`,
+      message: `Worktree already exists at ${worktreePath}.${healNote}`,
       worktreePath,
+      depsLinked: deps.linked,
+      depsInstalled: deps.installed,
+      depsHealed: deps.healed,
       linkage,
       backing,
     };
@@ -350,13 +658,13 @@ async function handleCreate(slug, flags, projectRoot, opts) {
   // the repo's DEFAULT branch — NOT the checkout's current HEAD — so the worktree
   // never silently inherits unrelated WIP commits (B2). An existing branch is
   // checked out as-is (no base applies).
-  const hasBranch = branchExists(branchName, runFile);
+  const hasBranch = branchExists(branchName, projectRoot, runFile);
   let base = null;
   if (hasBranch) {
-    runFile('git', ['worktree', 'add', worktreePath, branchName], { stdio: 'pipe' });
+    runFile('git', ['-C', projectRoot, 'worktree', 'add', worktreePath, branchName], { stdio: 'pipe' });
   } else {
     base = explicitBase || resolveDefaultBase(projectRoot, runFile);
-    runFile('git', ['worktree', 'add', worktreePath, '-b', branchName, base], { stdio: 'pipe' });
+    runFile('git', ['-C', projectRoot, 'worktree', 'add', worktreePath, '-b', branchName, base], { stdio: 'pipe' });
   }
 
   // Step 3: Populate node_modules (link to the shared install, else install).
@@ -375,11 +683,16 @@ async function handleCreate(slug, flags, projectRoot, opts) {
   }
 
   const linkage = await registerWorktreeLinkage({ projectRoot, worktreePath, branch: branchName, issueId, workFolder, opts });
+  if (linkage.conflict) {
+    return { success: false, error: linkage.reason, worktreePath, branch: branchName, linkage };
+  }
   const backing = await autoFileBackingIssue({ projectRoot, worktreePath, branch: branchName, issueId, opts });
 
   // Report the base so the fork point is never silent. `base` is null when an
   // existing branch was checked out (no fork happened).
   const baseNote = base ? `based on ${base}` : `existing branch ${branchName}`;
+  // Never let a heal be silent — a stale store is worth knowing about.
+  const healNote = deps.healed ? ' Healed dependencies (store was stale): reinstalled with --force.' : '';
   return {
     success: true,
     worktreePath,
@@ -387,9 +700,10 @@ async function handleCreate(slug, flags, projectRoot, opts) {
     base,
     depsLinked: deps.linked,
     depsInstalled: deps.installed,
+    depsHealed: deps.healed,
     linkage,
     backing,
-    output: `Created worktree ${worktreePath} on ${branchName} (${baseNote}).`,
+    output: `Created worktree ${worktreePath} on ${branchName} (${baseNote}).${healNote}`,
   };
 }
 

package/lib/core/runtime-graph.js

@@ -534,7 +534,7 @@ const RESOLVED_RUNTIME_GRAPH = {
       id: 'adapter.issue',
       kind: 'issue',
       label: 'Issue tracking adapter',
-      config: { primary: 'beads', mirrors: ['github'] },
+      config: { primary: 'kernel', mirrors: ['github'] },
     }),
     Adapter({
       id: 'adapter.harness',