@sushanglewis/lincoln 1.8.0 → 1.8.3

package/dist/main.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import fs11 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path13 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cli.ts
@@ -399,8 +399,8 @@ function initProject(projectRoot, options = {}) {
 }
 
 // src/commands/install.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import { spawn as spawn3 } from "child_process";
 
 // src/lib/syncClaude.ts
@@ -438,7 +438,12 @@ var COPY_SUBDIRS = [
   "stages",
   "schemas",
   "templates",
-  "harnesses"
+  "harnesses",
+  // Policies are data files consumed by hooks at runtime (e.g.
+  // .claude/policies/less-is-more.md read by on-session-start.sh,
+  // security.yaml read by pre-tool-use.sh). Without syncing them into the
+  // project, vendored installs silently skip those guardrails (#126).
+  "policies"
 ];
 function sha256(filePath) {
   const data = fs5.readFileSync(filePath);
@@ -659,9 +664,265 @@ async function syncHarness(harnessId, opts, syncClaude) {
   return report;
 }
 
-// src/lib/harnessDetect.ts
+// src/lib/syncSkills.ts
 import fs6 from "fs";
 import path7 from "path";
+import { execFile } from "child_process";
+import yaml2 from "js-yaml";
+
+// src/lib/semver.ts
+var SEMVER_CORE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+var NUMERIC_IDENTIFIER = /^\d+$/;
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) {
+    return void 0;
+  }
+  if (pa.major !== pb.major) return pa.major - pb.major;
+  if (pa.minor !== pb.minor) return pa.minor - pb.minor;
+  if (pa.patch !== pb.patch) return pa.patch - pb.patch;
+  return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+function parseVersion(version) {
+  const match = SEMVER_CORE.exec(version.trim());
+  if (!match) {
+    return void 0;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0) return 1;
+  if (b.length === 0) return -1;
+  const shared = Math.min(a.length, b.length);
+  for (let i = 0; i < shared; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === y) continue;
+    const xNumeric = NUMERIC_IDENTIFIER.test(x);
+    const yNumeric = NUMERIC_IDENTIFIER.test(y);
+    if (xNumeric && yNumeric) return Number(x) - Number(y);
+    if (xNumeric) return -1;
+    if (yNumeric) return 1;
+    return x < y ? -1 : 1;
+  }
+  return a.length - b.length;
+}
+
+// src/lib/syncSkills.ts
+var GIT_SOURCE = /^(https?:\/\/|git@)/;
+var FULL_SHA = /^[0-9a-f]{40}$/i;
+var PINNED_SEMVER = /^v?(\d+\.\d+\.\d+)$/;
+var NPM_GLOBAL_INSTALL = /^npm install -g (\S+)$/;
+var MAX_BUFFER = 16 * 1024 * 1024;
+var defaultRunner = (cmd, args) => new Promise((resolvePromise, rejectPromise) => {
+  execFile(cmd, args, { maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
+    if (err && !("code" in err && typeof err.code === "number")) {
+      rejectPromise(err);
+      return;
+    }
+    const code = err && typeof err.code === "number" ? err.code : 0;
+    resolvePromise({ code, stdout: String(stdout), stderr: String(stderr) });
+  });
+});
+async function syncExternalSkills(options) {
+  const report = { entries: [], warnings: [] };
+  const manifestPath = path7.join(options.payloadRoot, ".claude", "skills", "dependencies.yaml");
+  if (!fs6.existsSync(manifestPath)) {
+    report.warnings.push(`skill dependency manifest not found at ${manifestPath}; skipping external skill sync`);
+    return report;
+  }
+  let manifest;
+  try {
+    manifest = yaml2.load(fs6.readFileSync(manifestPath, "utf8")) ?? {};
+  } catch (err) {
+    report.warnings.push(
+      `failed to parse ${manifestPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return report;
+  }
+  const runCommand3 = options.runCommand ?? defaultRunner;
+  const platform = options.platform ?? (process.platform === "darwin" ? "macos" : process.platform === "linux" ? "linux" : process.platform);
+  for (const [name, cfg] of Object.entries(manifest.skills ?? {})) {
+    if (!cfg.source || cfg.source === "inline" || !GIT_SOURCE.test(cfg.source)) {
+      continue;
+    }
+    const enabled = cfg.default_install ?? cfg.required ?? true;
+    if (!enabled) {
+      report.entries.push({ name, status: "skipped-optional", detail: "default_install is false" });
+      continue;
+    }
+    if (cfg.type === "cli") {
+      await syncCli(name, cfg, options, platform, runCommand3, report);
+    } else {
+      await syncGitSkill(name, cfg, options, runCommand3, report);
+    }
+  }
+  return report;
+}
+async function syncGitSkill(name, cfg, options, runCommand3, report) {
+  const source = cfg.source;
+  const ref = cfg.ref ?? "";
+  const target = path7.join(options.skillsDir, name);
+  if (options.dryRun) {
+    const planned = fs6.existsSync(target) ? "verify pinned ref and update if behind" : `clone and pin to ${ref}`;
+    report.entries.push({ name, status: "dry-run", detail: `would ${planned}` });
+    return;
+  }
+  if (!fs6.existsSync(target)) {
+    const clone = await runCommand3("git", ["clone", source, target]);
+    if (clone.code !== 0) {
+      fail(report, name, `git clone failed: ${clone.stderr.trim() || `exit code ${clone.code}`}`);
+      return;
+    }
+    const checkout = await runCommand3("git", ["-C", target, "checkout", ref]);
+    if (checkout.code !== 0) {
+      fail(report, name, `git checkout ${ref} failed: ${checkout.stderr.trim() || `exit code ${checkout.code}`}`);
+      return;
+    }
+    report.entries.push({ name, status: "installed", detail: ref });
+    return;
+  }
+  const status = await runCommand3("git", ["-C", target, "status", "--porcelain"]);
+  if (status.code !== 0) {
+    fail(report, name, `git status failed (not a git repository?): ${status.stderr.trim() || `exit code ${status.code}`}`);
+    return;
+  }
+  if (status.stdout.trim() !== "") {
+    const detail = "working tree is dirty; skipping update (commit or stash local changes first)";
+    report.entries.push({ name, status: "skipped-dirty", detail });
+    report.warnings.push(`${name}: ${detail}`);
+    return;
+  }
+  const head = await runCommand3("git", ["-C", target, "rev-parse", "HEAD"]);
+  if (head.code !== 0) {
+    fail(report, name, `git rev-parse failed: ${head.stderr.trim() || `exit code ${head.code}`}`);
+    return;
+  }
+  if (head.stdout.trim() === ref) {
+    report.entries.push({ name, status: "current", detail: ref });
+    return;
+  }
+  const advertised = await isPinAdvertised(source, ref, runCommand3);
+  if (advertised) {
+    const fetch3 = await runCommand3("git", ["-C", target, "fetch", "origin", ref]);
+    if (fetch3.code === 0 && await checkoutFetchHead(name, target, runCommand3, report)) {
+      return;
+    }
+    if (fetch3.code !== 0) {
+      fail(report, name, `git fetch origin ${ref} failed: ${fetch3.stderr.trim() || `exit code ${fetch3.code}`}`);
+      return;
+    }
+    return;
+  }
+  const fetch2 = await runCommand3("git", ["-C", target, "fetch", "origin", ref]);
+  if (fetch2.code === 0) {
+    await checkoutFetchHead(name, target, runCommand3, report);
+    return;
+  }
+  if (FULL_SHA.test(ref)) {
+    const fetchAll = await runCommand3("git", ["-C", target, "fetch", "origin"]);
+    if (fetchAll.code !== 0) {
+      fail(report, name, `git fetch origin failed: ${fetchAll.stderr.trim() || `exit code ${fetchAll.code}`}`);
+      return;
+    }
+    const checkout = await runCommand3("git", ["-C", target, "checkout", ref]);
+    if (checkout.code !== 0) {
+      fail(report, name, `git checkout ${ref} failed: ${checkout.stderr.trim() || `exit code ${checkout.code}`}`);
+      return;
+    }
+    report.entries.push({ name, status: "updated", detail: ref });
+    return;
+  }
+  fail(report, name, `git fetch origin ${ref} failed: ${fetch2.stderr.trim() || `exit code ${fetch2.code}`}`);
+}
+async function isPinAdvertised(source, ref, runCommand3) {
+  const remote = await runCommand3("git", ["ls-remote", source]);
+  if (remote.code !== 0) {
+    return false;
+  }
+  return remote.stdout.split("\n").some((line) => line.split("	")[0]?.trim() === ref);
+}
+async function checkoutFetchHead(name, target, runCommand3, report) {
+  const checkout = await runCommand3("git", ["-C", target, "checkout", "FETCH_HEAD"]);
+  if (checkout.code !== 0) {
+    fail(report, name, `git checkout FETCH_HEAD failed: ${checkout.stderr.trim() || `exit code ${checkout.code}`}`);
+    return false;
+  }
+  report.entries.push({ name, status: "updated", detail: "checked out FETCH_HEAD" });
+  return true;
+}
+async function syncCli(name, cfg, options, platform, runCommand3, report) {
+  const binary = cfg.binary ?? name;
+  const installCommand = cfg.platforms?.[platform] ?? cfg.platforms?.linux;
+  const npmPackage = installCommand ? parseNpmGlobalInstall(installCommand) : void 0;
+  const pinned = cfg.ref ? pinnedSemver(cfg.ref) : void 0;
+  if (options.dryRun) {
+    const managed = npmPackage && pinned ? `install ${npmPackage}@${pinned} if missing or older` : "verify presence";
+    report.entries.push({ name, status: "dry-run", detail: `would ${managed}` });
+    return;
+  }
+  const whichCmd = process.platform === "win32" ? "where" : "which";
+  const found = await runCommand3(whichCmd, [binary]);
+  if (found.code !== 0) {
+    if (npmPackage && pinned) {
+      await npmInstall(name, npmPackage, pinned, runCommand3, report, "installed");
+      return;
+    }
+    fail(report, name, `CLI '${binary}' not found. Install manually (${platform}): ${installCommand ?? "see dependency manifest"}`);
+    return;
+  }
+  if (!npmPackage || !pinned) {
+    report.entries.push({ name, status: "current", detail: `${binary} present` });
+    return;
+  }
+  const version = await runCommand3(binary, ["--version"]);
+  const installed = version.code === 0 ? version.stdout.split("\n")[0]?.trim() ?? "" : "";
+  const comparison = installed ? compareVersions(installed, pinned) : void 0;
+  if (comparison === void 0) {
+    report.entries.push({
+      name,
+      status: "current",
+      detail: `could not parse installed version '${installed}'; leaving ${binary} as-is`
+    });
+    return;
+  }
+  if (comparison >= 0) {
+    report.entries.push({ name, status: "current", detail: `${binary} ${installed}` });
+    return;
+  }
+  await npmInstall(name, npmPackage, pinned, runCommand3, report, "updated");
+}
+async function npmInstall(name, npmPackage, version, runCommand3, report, status) {
+  const result = await runCommand3("npm", ["install", "-g", `${npmPackage}@${version}`]);
+  if (result.code !== 0) {
+    fail(report, name, `npm install -g ${npmPackage}@${version} failed: ${result.stderr.trim() || `exit code ${result.code}`}`);
+    return;
+  }
+  report.entries.push({ name, status, detail: `${npmPackage}@${version}` });
+}
+function parseNpmGlobalInstall(command) {
+  const match = NPM_GLOBAL_INSTALL.exec(command.trim());
+  return match?.[1];
+}
+function pinnedSemver(ref) {
+  const match = PINNED_SEMVER.exec(ref.trim());
+  return match?.[0].replace(/^v/, "");
+}
+function fail(report, name, detail) {
+  report.entries.push({ name, status: "failed", detail });
+  report.warnings.push(`${name}: ${detail}`);
+}
+
+// src/lib/harnessDetect.ts
+import fs7 from "fs";
+import path8 from "path";
 import os2 from "os";
 var HARNESS_SPECS = [
   {
@@ -675,9 +936,9 @@ var HARNESS_SPECS = [
 function detectGlobalHarnesses(overrideHomeDir) {
   const homeDir = overrideHomeDir ?? os2.homedir();
   return HARNESS_SPECS.map((spec) => {
-    const configDir = path7.join(homeDir, spec.configDirName);
-    const installed = fs6.existsSync(configDir);
-    const pluginManaged = spec.pluginMarker ? fs6.existsSync(path7.join(configDir, spec.pluginMarker)) : false;
+    const configDir = path8.join(homeDir, spec.configDirName);
+    const installed = fs7.existsSync(configDir);
+    const pluginManaged = spec.pluginMarker ? fs7.existsSync(path8.join(configDir, spec.pluginMarker)) : false;
     return {
       id: spec.id,
       installed,
@@ -869,6 +1130,7 @@ function createDefaultDeps2() {
     paths: resolveLincolnPaths(),
     payloadRoot: resolvePayloadRoot() || "",
     syncHarnesses,
+    syncExternalSkills,
     createPrompt,
     resolvePythonForVenv,
     isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY)
@@ -881,7 +1143,7 @@ async function install(options, deps = createDefaultDeps2()) {
     return 1;
   }
   const payloadRoot = deps.payloadRoot;
-  if (!payloadRoot || !fs7.existsSync(payloadRoot)) {
+  if (!payloadRoot || !fs8.existsSync(payloadRoot)) {
     console.error('Lincoln payload not found. Run "npm install -g @sushanglewis/lincoln" first.');
     return 1;
   }
@@ -900,15 +1162,15 @@ async function install(options, deps = createDefaultDeps2()) {
     return 1;
   }
   if (!options.dryRun) {
-    const versionDir = path8.join(deps.paths.versionsDir, version);
-    fs7.mkdirSync(versionDir, { recursive: true });
-    fs7.cpSync(payloadRoot, versionDir, { recursive: true, force: true });
+    const versionDir = path9.join(deps.paths.versionsDir, version);
+    fs8.mkdirSync(versionDir, { recursive: true });
+    fs8.cpSync(payloadRoot, versionDir, { recursive: true, force: true });
     try {
-      fs7.rmSync(deps.paths.currentDir, { recursive: true, force: true });
-      fs7.symlinkSync(versionDir, deps.paths.currentDir);
+      fs8.rmSync(deps.paths.currentDir, { recursive: true, force: true });
+      fs8.symlinkSync(versionDir, deps.paths.currentDir);
     } catch {
-      fs7.rmSync(deps.paths.currentDir, { recursive: true, force: true });
-      fs7.cpSync(versionDir, deps.paths.currentDir, { recursive: true, force: true });
+      fs8.rmSync(deps.paths.currentDir, { recursive: true, force: true });
+      fs8.cpSync(versionDir, deps.paths.currentDir, { recursive: true, force: true });
     }
   }
   const reports = await deps.syncHarnesses({
@@ -928,9 +1190,30 @@ async function install(options, deps = createDefaultDeps2()) {
       managedFiles: collectManagedFiles(reports)
     });
   }
-  printSummary(options, version, harnesses, reports);
+  const skillReport = await syncSkillLibraries(options, deps, harnesses);
+  printSummary(options, version, harnesses, reports, skillReport);
   return 0;
 }
+async function syncSkillLibraries(options, deps, harnesses) {
+  if (!harnesses.includes("claude-code") || !deps.syncExternalSkills) {
+    return void 0;
+  }
+  const payloadRoot = deps.paths.currentDir;
+  const manifestPath = path9.join(payloadRoot, ".claude", "skills", "dependencies.yaml");
+  if (!fs8.existsSync(manifestPath)) {
+    return void 0;
+  }
+  try {
+    return await deps.syncExternalSkills({
+      payloadRoot,
+      skillsDir: path9.join(deps.paths.claudeDir, "skills"),
+      dryRun: options.dryRun
+    });
+  } catch (err) {
+    console.warn(`  warning: external skill sync failed: ${err instanceof Error ? err.message : String(err)}`);
+    return void 0;
+  }
+}
 async function resolvePythonIfNeeded(options, deps, harnesses) {
   const needsPython = !options.dryRun && !options.noVenv && harnesses.some((id) => id === "codex" || id === "opencode");
   if (!needsPython) {
@@ -991,7 +1274,7 @@ function collectManagedFiles(reports) {
   }
   return files;
 }
-function printSummary(options, version, harnesses, reports) {
+function printSummary(options, version, harnesses, reports, skillReport) {
   const warnings = collectWarnings(reports);
   if (options.dryRun) {
     console.log(`Dry run: would install Lincoln ${version} for harnesses: ${harnesses.join(", ")}`);
@@ -1002,6 +1285,13 @@ function printSummary(options, version, harnesses, reports) {
     const count = report.written.length + report.skipped.length + report.preserved.length;
     console.log(`  ${harnessId}: ${count} file(s)`);
   }
+  if (skillReport) {
+    for (const entry of skillReport.entries) {
+      const detail = entry.detail ? ` (${entry.detail})` : "";
+      console.log(`  skill ${entry.name}: ${entry.status}${detail}`);
+    }
+    warnings.push(...skillReport.warnings);
+  }
   for (const warning of warnings) {
     console.warn(`  warning: ${warning}`);
   }
@@ -1062,7 +1352,7 @@ async function resolvePythonForVenv(envOverride = process.env.LINCOLN_PYTHON, ca
   return void 0;
 }
 function venvPythonPath(paths) {
-  return path8.join(
+  return path9.join(
     paths.venvDir,
     process.platform === "win32" ? "Scripts" : "bin",
     process.platform === "win32" ? "python.exe" : "python"
@@ -1070,17 +1360,17 @@ function venvPythonPath(paths) {
 }
 async function setupVenv(paths, payloadRoot, pythonCommand) {
   const pythonExe = venvPythonPath(paths);
-  if (!fs7.existsSync(pythonExe)) {
+  if (!fs8.existsSync(pythonExe)) {
     console.log("Creating Lincoln virtual environment...");
     const venvCode = await runCommand2(pythonCommand, ["-m", "venv", paths.venvDir]);
     if (venvCode !== 0) {
       throw new Error(`Failed to create virtual environment (exit code ${venvCode})`);
     }
   }
-  const requirementsPath = path8.join(payloadRoot, "requirements.txt");
-  if (fs7.existsSync(requirementsPath)) {
+  const requirementsPath = path9.join(payloadRoot, "requirements.txt");
+  if (fs8.existsSync(requirementsPath)) {
     console.log("Installing Python dependencies...");
-    const pipExe = path8.join(
+    const pipExe = path9.join(
       paths.venvDir,
       process.platform === "win32" ? "Scripts" : "bin",
       process.platform === "win32" ? "pip.exe" : "pip"
@@ -1152,51 +1442,6 @@ function encodePackageName(packageName) {
   return encodeURIComponent(packageName);
 }
 
-// src/lib/semver.ts
-var SEMVER_CORE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
-var NUMERIC_IDENTIFIER = /^\d+$/;
-function compareVersions(a, b) {
-  const pa = parseVersion(a);
-  const pb = parseVersion(b);
-  if (!pa || !pb) {
-    return void 0;
-  }
-  if (pa.major !== pb.major) return pa.major - pb.major;
-  if (pa.minor !== pb.minor) return pa.minor - pb.minor;
-  if (pa.patch !== pb.patch) return pa.patch - pb.patch;
-  return comparePrerelease(pa.prerelease, pb.prerelease);
-}
-function parseVersion(version) {
-  const match = SEMVER_CORE.exec(version.trim());
-  if (!match) {
-    return void 0;
-  }
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3]),
-    prerelease: match[4] ? match[4].split(".") : []
-  };
-}
-function comparePrerelease(a, b) {
-  if (a.length === 0 && b.length === 0) return 0;
-  if (a.length === 0) return 1;
-  if (b.length === 0) return -1;
-  const shared = Math.min(a.length, b.length);
-  for (let i = 0; i < shared; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x === y) continue;
-    const xNumeric = NUMERIC_IDENTIFIER.test(x);
-    const yNumeric = NUMERIC_IDENTIFIER.test(y);
-    if (xNumeric && yNumeric) return Number(x) - Number(y);
-    if (xNumeric) return -1;
-    if (yNumeric) return 1;
-    return x < y ? -1 : 1;
-  }
-  return a.length - b.length;
-}
-
 // src/commands/update.ts
 var PACKAGE_NAME = "@sushanglewis/lincoln";
 function createDefaultDeps3() {
@@ -1276,8 +1521,8 @@ function runNpmInstallGlobal(packageName, version) {
 }
 
 // src/commands/use.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 import { spawn as spawn5 } from "child_process";
 var PACKAGE_NAME2 = "@sushanglewis/lincoln";
 var SEMVER_REGEX = /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -1319,8 +1564,8 @@ async function use(spec, options, deps = {}) {
     console.error(`Failed to resolve version ${spec}: ${message}`);
     return 1;
   }
-  const versionDir = path9.join(resolved.paths.versionsDir, version);
-  const alreadyInstalled = fs8.existsSync(versionDir);
+  const versionDir = path10.join(resolved.paths.versionsDir, version);
+  const alreadyInstalled = fs9.existsSync(versionDir);
   if (options.dryRun) {
     if (alreadyInstalled) {
       console.log(`Dry run: would switch ${resolved.paths.currentDir} to ${versionDir}`);
@@ -1343,7 +1588,7 @@ async function use(spec, options, deps = {}) {
       console.error(`Failed to install ${PACKAGE_NAME2}@${version}: ${message}`);
       return 1;
     }
-    if (!fs8.existsSync(versionDir)) {
+    if (!fs9.existsSync(versionDir)) {
       try {
         await copyVersionFromNpmGlobal(resolved, versionDir);
       } catch (err) {
@@ -1352,7 +1597,7 @@ async function use(spec, options, deps = {}) {
         return 1;
       }
     }
-    if (!fs8.existsSync(versionDir)) {
+    if (!fs9.existsSync(versionDir)) {
       console.error(
         `Provisioning ${PACKAGE_NAME2}@${version} did not produce ${versionDir}; cannot switch versions.`
       );
@@ -1389,21 +1634,21 @@ async function copyVersionFromNpmGlobal(deps, versionDir) {
   if (!globalRoot) {
     return;
   }
-  const packageRoot = path9.join(globalRoot, ...PACKAGE_NAME2.split("/"));
-  if (!fs8.existsSync(packageRoot)) {
+  const packageRoot = path10.join(globalRoot, ...PACKAGE_NAME2.split("/"));
+  if (!fs9.existsSync(packageRoot)) {
     return;
   }
-  fs8.mkdirSync(path9.dirname(versionDir), { recursive: true });
-  fs8.cpSync(packageRoot, versionDir, { recursive: true });
+  fs9.mkdirSync(path10.dirname(versionDir), { recursive: true });
+  fs9.cpSync(packageRoot, versionDir, { recursive: true });
 }
 function switchCurrentLink(paths, versionDir) {
-  fs8.mkdirSync(paths.lincolnHome, { recursive: true });
+  fs9.mkdirSync(paths.lincolnHome, { recursive: true });
   try {
-    fs8.rmSync(paths.currentDir, { recursive: true, force: true });
-    fs8.symlinkSync(versionDir, paths.currentDir);
+    fs9.rmSync(paths.currentDir, { recursive: true, force: true });
+    fs9.symlinkSync(versionDir, paths.currentDir);
   } catch {
-    fs8.rmSync(paths.currentDir, { recursive: true, force: true });
-    fs8.cpSync(versionDir, paths.currentDir, { recursive: true, force: true });
+    fs9.rmSync(paths.currentDir, { recursive: true, force: true });
+    fs9.cpSync(versionDir, paths.currentDir, { recursive: true, force: true });
   }
 }
 function defaultInstallOptions2() {
@@ -1439,12 +1684,12 @@ function runNpmRootGlobal() {
 }
 
 // src/commands/migrateProject.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 
 // src/lib/projectFiles.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path11 from "path";
 import crypto2 from "crypto";
 var FRAMEWORK_ALLOWLIST_DIRS = [".claude", ".claude-plugin", "scripts", "tools"];
 var FRAMEWORK_ALLOWLIST_FILES = [
@@ -1479,10 +1724,10 @@ var FRAMEWORK_SKIP_PATHS = /* @__PURE__ */ new Set([
   "tools/lincoln-installer/coverage"
 ]);
 function sha2562(filePath) {
-  return crypto2.createHash("sha256").update(fs9.readFileSync(filePath)).digest("hex");
+  return crypto2.createHash("sha256").update(fs10.readFileSync(filePath)).digest("hex");
 }
 function isDenied(relativePath) {
-  const parts = relativePath.split(path10.sep);
+  const parts = relativePath.split(path11.sep);
   for (const part of parts) {
     if (FRAMEWORK_DENYLIST_NAMES.has(part)) return true;
     for (const prefix of FRAMEWORK_DENYLIST_PREFIXES) {
@@ -1490,14 +1735,14 @@ function isDenied(relativePath) {
     }
   }
   for (const skip of FRAMEWORK_SKIP_PATHS) {
-    if (relativePath === skip || relativePath.startsWith(skip + path10.sep)) return true;
+    if (relativePath === skip || relativePath.startsWith(skip + path11.sep)) return true;
   }
   return false;
 }
 function isAllowlisted(relativePath) {
   if (FRAMEWORK_ALLOWLIST_FILES.includes(relativePath)) return true;
   for (const dir of FRAMEWORK_ALLOWLIST_DIRS) {
-    if (relativePath === dir || relativePath.startsWith(dir + path10.sep)) return true;
+    if (relativePath === dir || relativePath.startsWith(dir + path11.sep)) return true;
   }
   return false;
 }
@@ -1518,10 +1763,10 @@ function isPreserved(relativePath) {
 function listVendoredFrameworkFiles(payloadRoot, projectRoot) {
   const report = { removable: [], modified: [], preserved: [] };
   function walk(dir) {
-    const entries = fs9.readdirSync(dir, { withFileTypes: true });
+    const entries = fs10.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path10.join(dir, entry.name);
-      const relativePath = path10.relative(projectRoot, fullPath);
+      const fullPath = path11.join(dir, entry.name);
+      const relativePath = path11.relative(projectRoot, fullPath);
       if (entry.isDirectory()) {
         if (isPreservedDir(relativePath)) {
           walk(fullPath);
@@ -1536,8 +1781,8 @@ function listVendoredFrameworkFiles(payloadRoot, projectRoot) {
       }
       if (isDenied(relativePath)) continue;
       if (!isAllowlisted(relativePath)) continue;
-      const payloadFile = path10.join(payloadRoot, relativePath);
-      if (!fs9.existsSync(payloadFile)) {
+      const payloadFile = path11.join(payloadRoot, relativePath);
+      if (!fs10.existsSync(payloadFile)) {
         report.modified.push(relativePath);
         continue;
       }
@@ -1548,7 +1793,7 @@ function listVendoredFrameworkFiles(payloadRoot, projectRoot) {
       }
     }
   }
-  if (fs9.existsSync(projectRoot)) {
+  if (fs10.existsSync(projectRoot)) {
     walk(projectRoot);
   }
   return report;
@@ -1564,11 +1809,11 @@ function createDefaultDeps5() {
 }
 async function migrateProject(projectRoot, options = {}, deps = createDefaultDeps5()) {
   const payloadRoot = deps.paths.currentDir;
-  if (!fs10.existsSync(payloadRoot)) {
+  if (!fs11.existsSync(payloadRoot)) {
     console.error(`Lincoln payload not found at ${payloadRoot}. Run "lincoln install" first.`);
     return 1;
   }
-  const absoluteProjectRoot = path11.resolve(projectRoot);
+  const absoluteProjectRoot = path12.resolve(projectRoot);
   const report = deps.listVendoredFrameworkFiles(payloadRoot, absoluteProjectRoot);
   if (options.dryRun) {
     console.log(`Dry run: would migrate ${absoluteProjectRoot}`);
@@ -1592,15 +1837,15 @@ async function migrateProject(projectRoot, options = {}, deps = createDefaultDep
     return 1;
   }
   for (const file of report.removable) {
-    const filePath = path11.join(absoluteProjectRoot, file);
+    const filePath = path12.join(absoluteProjectRoot, file);
     try {
-      fs10.rmSync(filePath);
-      let dir = path11.dirname(filePath);
-      while (dir !== absoluteProjectRoot && fs10.existsSync(dir)) {
-        const entries = fs10.readdirSync(dir);
+      fs11.rmSync(filePath);
+      let dir = path12.dirname(filePath);
+      while (dir !== absoluteProjectRoot && fs11.existsSync(dir)) {
+        const entries = fs11.readdirSync(dir);
         if (entries.length === 0) {
-          fs10.rmdirSync(dir);
-          dir = path11.dirname(dir);
+          fs11.rmdirSync(dir);
+          dir = path12.dirname(dir);
         } else {
           break;
         }
@@ -1749,7 +1994,7 @@ async function main(argv) {
   console.log(USAGE);
   return 0;
 }
-if (process.argv[1] && path12.resolve(fs11.realpathSync(fileURLToPath2(import.meta.url))) === path12.resolve(fs11.realpathSync(process.argv[1]))) {
+if (process.argv[1] && path13.resolve(fs12.realpathSync(fileURLToPath2(import.meta.url))) === path13.resolve(fs12.realpathSync(process.argv[1]))) {
   main(process.argv).then((code) => process.exit(code)).catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);