xtrm-tools 0.7.2 → 0.7.4

package/cli/dist/index.cjs

@@ -8212,7 +8212,7 @@ var require_dist = __commonJS({
         });
       };
     }
-    var prompts5 = require_prompts();
+    var prompts6 = require_prompts();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -8263,7 +8263,7 @@ var require_dist = __commonJS({
             var _question2 = question;
             name = _question2.name;
             type = _question2.type;
-            if (prompts5[type] === void 0) {
+            if (prompts6[type] === void 0) {
               throw new Error(`prompt type (${type}) is not defined`);
             }
             if (override2[question.name] !== void 0) {
@@ -8274,7 +8274,7 @@ var require_dist = __commonJS({
               }
             }
             try {
-              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts5[type](question);
+              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts6[type](question);
               answers[name] = answer = yield getFormattedAnswer(question, answer, true);
               quit = yield onSubmit(question, answer, answers);
             } catch (err) {
@@ -8306,7 +8306,7 @@ var require_dist = __commonJS({
     }
     module2.exports = Object.assign(prompt, {
       prompt,
-      prompts: prompts5,
+      prompts: prompts6,
       inject,
       override
     });
@@ -10393,7 +10393,7 @@ var require_prompts2 = __commonJS({
 var require_lib2 = __commonJS({
   "../node_modules/prompts/lib/index.js"(exports2, module2) {
     "use strict";
-    var prompts5 = require_prompts2();
+    var prompts6 = require_prompts2();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -10425,7 +10425,7 @@ var require_lib2 = __commonJS({
           throw new Error("prompt message is required");
         }
         ({ name, type } = question);
-        if (prompts5[type] === void 0) {
+        if (prompts6[type] === void 0) {
           throw new Error(`prompt type (${type}) is not defined`);
         }
         if (override2[question.name] !== void 0) {
@@ -10436,7 +10436,7 @@ var require_lib2 = __commonJS({
           }
         }
         try {
-          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts5[type](question);
+          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts6[type](question);
           answers[name] = answer = await getFormattedAnswer(question, answer, true);
           quit = await onSubmit(question, answer, answers);
         } catch (err) {
@@ -10459,7 +10459,7 @@ var require_lib2 = __commonJS({
     function override(answers) {
       prompt._override = Object.assign({}, answers);
     }
-    module2.exports = Object.assign(prompt, { prompt, prompts: prompts5, inject, override });
+    module2.exports = Object.assign(prompt, { prompt, prompts: prompts6, inject, override });
   }
 });
 
@@ -29517,7 +29517,7 @@ var kleur_default = $;
 
 // src/commands/claude.ts
 var import_node_child_process2 = require("child_process");
-var import_fs_extra9 = __toESM(require_lib(), 1);
+var import_fs_extra8 = __toESM(require_lib(), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 
 // src/utils/repo-root.ts
@@ -29784,11 +29784,14 @@ var import_node_path5 = __toESM(require("path"), 1);
 var import_node_child_process = require("child_process");
 var import_node_fs = require("fs");
 
-// src/core/pi-runtime.ts
-var import_child_process2 = require("child_process");
-var import_fs_extra7 = __toESM(require_lib(), 1);
+// src/core/skills-scaffold.ts
 var import_path3 = __toESM(require("path"), 1);
-var import_node_os = require("os");
+var import_fs_extra7 = __toESM(require_lib(), 1);
+
+// src/core/skills-materializer.ts
+var import_node_crypto = require("crypto");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_fs_extra6 = __toESM(require_lib(), 1);
 
 // src/core/skills-layout.ts
 var import_node_path = __toESM(require("path"), 1);
@@ -43760,11 +43763,6 @@ async function validateSkillsInvariants(skillsRoot) {
   return violations;
 }
 
-// src/core/skills-materializer.ts
-var import_node_crypto = require("crypto");
-var import_node_path4 = __toESM(require("path"), 1);
-var import_fs_extra6 = __toESM(require_lib(), 1);
-
 // src/core/skills-state.ts
 var import_fs_extra5 = __toESM(require_lib(), 1);
 var runtimeEnabledPacksSchema = external_exports.strictObject({
@@ -43965,466 +43963,33 @@ async function rebuildAllRuntimeActiveViews(skillsRoot) {
   return results;
 }
 
-// src/core/pi-runtime.ts
-function resolvePkgRoot() {
-  const candidates = [
-    import_path3.default.resolve(__dirname, "../.."),
-    import_path3.default.resolve(__dirname, "../../..")
-  ];
-  for (const c of candidates) {
-    if (import_fs_extra7.default.existsSync(import_path3.default.join(c, ".xtrm", "extensions"))) return c;
-  }
-  return candidates[0];
-}
-var PI_AGENT_DIR = process.env.PI_AGENT_DIR || import_path3.default.join((0, import_node_os.homedir)(), ".pi", "agent");
-var PROJECT_EXTENSIONS_ENTRY = "../.xtrm/extensions";
-var PROJECT_SKILLS_ENTRY = "../.xtrm/skills/active/pi";
-var MANAGED_EXTENSIONS = [
-  { id: "core", displayName: "@xtrm/pi-core", isLibrary: true, required: true },
-  { id: "auto-session-name", displayName: "auto-session-name", required: false },
-  { id: "auto-update", displayName: "auto-update", required: false },
-  { id: "beads", displayName: "beads", required: true },
-  { id: "compact-header", displayName: "compact-header", required: false },
-  { id: "custom-footer", displayName: "custom-footer", required: true },
-  { id: "custom-provider-qwen-cli", displayName: "custom-provider-qwen-cli", required: false },
-  { id: "git-checkpoint", displayName: "git-checkpoint", required: false },
-  { id: "lsp-bootstrap", displayName: "lsp-bootstrap", required: false },
-  { id: "pi-serena-compact", displayName: "pi-serena-compact", required: false },
-  { id: "quality-gates", displayName: "quality-gates", required: true },
-  { id: "service-skills", displayName: "service-skills", required: false },
-  { id: "session-flow", displayName: "session-flow", required: true },
-  { id: "xtrm-loader", displayName: "xtrm-loader", required: true },
-  { id: "xtrm-ui", displayName: "xtrm-ui", required: true }
-];
-var MANAGED_PACKAGES = [
-  { id: "npm:pi-gitnexus", displayName: "pi-gitnexus", required: true },
-  { id: "npm:pi-serena-tools", displayName: "pi-serena-tools", required: true },
-  { id: "npm:@zenobius/pi-worktrees", displayName: "pi-worktrees", required: true },
-  { id: "npm:@robhowley/pi-structured-return", displayName: "pi-structured-return", required: true },
-  { id: "npm:@aliou/pi-guardrails", displayName: "pi-guardrails", required: false },
-  { id: "npm:@aliou/pi-processes", displayName: "pi-processes", required: true }
-];
-function getInstalledPiPackages() {
-  const result = (0, import_child_process2.spawnSync)("pi", ["list"], { encoding: "utf8", stdio: "pipe" });
-  if (result.status !== 0) return [];
-  const output = result.stdout;
-  const packages = [];
-  for (const line of output.split("\n")) {
-    const match = line.match(/^\s+(npm:[\w\-/@]+)/);
-    if (match) packages.push(match[1]);
-  }
-  return packages.sort();
-}
-async function listInstalledExtensions(targetDir) {
-  if (!await import_fs_extra7.default.pathExists(targetDir)) return [];
-  const entries = await import_fs_extra7.default.readdir(targetDir, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name).sort();
-}
-async function inventoryPiRuntime(sourceDir, targetDir) {
-  const installedExtNames = await listInstalledExtensions(targetDir);
-  const extensionStatuses = [];
-  const missingExtensions = [];
-  const staleExtensions = [];
-  const orphanedExtensions = [];
-  for (const ext of MANAGED_EXTENSIONS) {
-    const srcPath = import_path3.default.join(sourceDir, ext.id);
-    const dstPath = import_path3.default.join(targetDir, ext.id);
-    const srcExists = await import_fs_extra7.default.pathExists(srcPath);
-    const dstExists = await import_fs_extra7.default.pathExists(dstPath);
-    if (!srcExists) {
-      continue;
-    }
-    if (!dstExists) {
-      const status2 = { ext, installed: false };
-      extensionStatuses.push(status2);
-      missingExtensions.push(status2);
-      continue;
-    }
-    let isStale = false;
-    if (srcPath !== dstPath) {
-      const dstStat = await import_fs_extra7.default.lstat(dstPath);
-      if (dstStat.isSymbolicLink()) {
-        const linkTarget = await import_fs_extra7.default.readlink(dstPath);
-        const resolvedTarget = import_path3.default.resolve(import_path3.default.dirname(dstPath), linkTarget);
-        isStale = resolvedTarget !== import_path3.default.resolve(srcPath);
-      } else {
-        isStale = true;
-      }
-    }
-    const status = {
-      ext,
-      installed: true,
-      stale: isStale
-    };
-    extensionStatuses.push(status);
-    if (isStale) {
-      staleExtensions.push(status);
-    }
-  }
-  const managedIds = new Set(MANAGED_EXTENSIONS.map((e) => e.id));
-  for (const name of installedExtNames) {
-    if (!managedIds.has(name)) {
-      orphanedExtensions.push(name);
-    }
-  }
-  const installedPkgIds = getInstalledPiPackages();
-  const packageStatuses = [];
-  const missingPackages = [];
-  for (const pkg of MANAGED_PACKAGES) {
-    const isInstalled = installedPkgIds.includes(pkg.id);
-    const status = { pkg, installed: isInstalled };
-    packageStatuses.push(status);
-    if (!isInstalled) {
-      missingPackages.push(status);
-    }
-  }
-  const allRequiredPresent = missingExtensions.every((s) => !s.ext.required) && staleExtensions.every((s) => !s.ext.required) && missingPackages.every((s) => !s.pkg.required);
-  const allPresent = missingExtensions.length === 0 && staleExtensions.length === 0 && orphanedExtensions.length === 0 && missingPackages.length === 0;
-  return {
-    extensions: extensionStatuses,
-    packages: packageStatuses,
-    missingExtensions,
-    staleExtensions,
-    orphanedExtensions,
-    missingPackages,
-    allRequiredPresent,
-    allPresent
-  };
-}
-function renderPiRuntimePlan(plan) {
-  console.log(kleur_default.bold("\n  Pi Runtime"));
-  console.log(kleur_default.dim("  " + "-".repeat(50)));
-  const extTotal = plan.extensions.length;
-  const extOk = plan.extensions.filter((s) => s.installed && !s.stale).length;
-  console.log(kleur_default.dim(`  Extensions: ${extOk}/${extTotal} up-to-date`));
-  if (plan.missingExtensions.length > 0) {
-    const names = plan.missingExtensions.map((s) => s.ext.displayName).join(", ");
-    console.log(kleur_default.yellow(`  Missing:    ${names}`));
-  }
-  if (plan.staleExtensions.length > 0) {
-    const names = plan.staleExtensions.map((s) => s.ext.displayName).join(", ");
-    console.log(kleur_default.yellow(`  Stale:      ${names}`));
-  }
-  if (plan.orphanedExtensions.length > 0) {
-    const names = plan.orphanedExtensions.join(", ");
-    console.log(kleur_default.red(`  Orphaned:   ${names} (will remove)`));
-  }
-  const pkgTotal = plan.packages.length;
-  const pkgOk = plan.packages.filter((s) => s.installed).length;
-  console.log(kleur_default.dim(`  Packages:   ${pkgOk}/${pkgTotal} installed`));
-  if (plan.missingPackages.length > 0) {
-    const names = plan.missingPackages.map((s) => s.pkg.displayName).join(", ");
-    console.log(kleur_default.yellow(`  Missing:    ${names}`));
-  }
-  console.log(kleur_default.dim("  " + "-".repeat(50)));
-  if (plan.allPresent) {
-    console.log(t.success("  \u2713 All extensions and packages present.\n"));
-  } else if (plan.allRequiredPresent) {
-    console.log(t.success("  \u2713 All required items present."));
-    const optionalMissing = [
-      ...plan.missingExtensions.filter((s) => !s.ext.required),
-      ...plan.missingPackages.filter((s) => !s.pkg.required)
-    ];
-    if (optionalMissing.length > 0) {
-      const names = optionalMissing.map(
-        (s) => "ext" in s ? s.ext.displayName : s.pkg.displayName
-      ).join(", ");
-      console.log(kleur_default.dim(`  \u25CB Optional not installed: ${names}
-`));
-    } else {
-      console.log("");
-    }
-  } else {
-    console.log(kleur_default.yellow("  \u26A0 Missing required items.\n"));
-  }
-}
-async function ensureCorePackageSymlink(coreSrcDir, projectRoot, dryRun, log) {
-  if (!await import_fs_extra7.default.pathExists(coreSrcDir)) return;
-  const extensionsDir = import_path3.default.join(projectRoot, ".xtrm", "extensions");
-  const nodeModulesDir = import_path3.default.join(extensionsDir, "node_modules", "@xtrm");
-  const symlinkPath = import_path3.default.join(nodeModulesDir, "pi-core");
-  const existing = await import_fs_extra7.default.lstat(symlinkPath).catch(() => null);
-  if (existing) return;
-  if (dryRun) {
-    log?.(kleur_default.dim(`[DRY RUN] would create @xtrm/pi-core symlink`));
-    return;
-  }
-  await import_fs_extra7.default.ensureDir(nodeModulesDir);
-  const relTarget = import_path3.default.relative(nodeModulesDir, coreSrcDir);
-  await import_fs_extra7.default.symlink(relTarget, symlinkPath);
-  log?.(kleur_default.dim(`Created @xtrm/pi-core symlink \u2192 .xtrm/extensions/node_modules/@xtrm/pi-core`));
-}
-function isXtrmExtensionsSetting(entry) {
-  const normalizedEntry = entry.replaceAll("\\", "/").replace(/\/$/, "");
-  return normalizedEntry === PROJECT_EXTENSIONS_ENTRY || normalizedEntry === ".xtrm/extensions";
-}
-async function cleanupLegacyProjectExtensionCopies(projectRoot, dryRun, log) {
-  const piSettingsPath = import_path3.default.join(projectRoot, ".pi", "settings.json");
-  let existingSettings = {};
-  try {
-    existingSettings = await import_fs_extra7.default.readJson(piSettingsPath);
-  } catch {
-    return { removed: [], failed: [] };
-  }
-  const pointsToXtrmExtensions = (existingSettings.extensions ?? []).some(isXtrmExtensionsSetting);
-  if (!pointsToXtrmExtensions) return { removed: [], failed: [] };
-  const legacyExtensionsDir = import_path3.default.join(projectRoot, ".pi", "extensions");
-  if (!await import_fs_extra7.default.pathExists(legacyExtensionsDir)) return { removed: [], failed: [] };
-  const removed = [];
-  const failed = [];
-  for (const ext of MANAGED_EXTENSIONS) {
-    const legacyExtPath = import_path3.default.join(legacyExtensionsDir, ext.id);
-    const legacyStat = await import_fs_extra7.default.lstat(legacyExtPath).catch(() => null);
-    if (!legacyStat || legacyStat.isSymbolicLink() || !legacyStat.isDirectory()) {
-      continue;
-    }
-    if (dryRun) {
-      log?.(kleur_default.dim(`[DRY RUN] - .pi/extensions/${ext.id} (legacy copy)`));
-      continue;
-    }
-    try {
-      await import_fs_extra7.default.remove(legacyExtPath);
-      removed.push(ext.id);
-      log?.(kleur_default.dim(`Removed legacy .pi/extensions/${ext.id}`));
-    } catch (err) {
-      failed.push(ext.id);
-      log?.(kleur_default.red(`\u2717 Failed to remove legacy .pi/extensions/${ext.id}: ${err}`));
-    }
-  }
-  return { removed, failed };
-}
-async function updatePiSettings(projectRoot, dryRun, log) {
-  const piSettingsPath = import_path3.default.join(projectRoot, ".pi", "settings.json");
-  if (dryRun) {
-    log?.(kleur_default.dim(`[DRY RUN] would update .pi/settings.json`));
-    return;
-  }
-  let existingSettings = {};
-  try {
-    existingSettings = await import_fs_extra7.default.readJson(piSettingsPath);
-  } catch {
-  }
-  const existingPackages = (existingSettings.packages ?? []).filter(
-    (p) => !p.startsWith("./extensions/")
-  );
-  await import_fs_extra7.default.ensureDir(import_path3.default.join(projectRoot, ".pi"));
-  await import_fs_extra7.default.writeJson(piSettingsPath, {
-    ...existingSettings,
-    extensions: [PROJECT_EXTENSIONS_ENTRY],
-    skills: [PROJECT_SKILLS_ENTRY],
-    packages: existingPackages
-  }, { spaces: 2 });
-  log?.(kleur_default.dim(`Updated .pi/settings.json \u2192 .xtrm/extensions + .xtrm/skills/active/pi`));
-}
-async function executePiSync(plan, sourceDir, targetDir, opts = {}) {
-  const {
-    dryRun = false,
-    isGlobal = false,
-    projectRoot,
-    removeOrphaned = true,
-    log = (msg) => console.log(kleur_default.dim(`    ${msg}`))
-  } = opts;
-  const result = {
-    extensionsAdded: [],
-    extensionsUpdated: [],
-    extensionsRemoved: [],
-    packagesInstalled: [],
-    failed: []
-  };
-  if (!dryRun) {
-    await import_fs_extra7.default.ensureDir(targetDir);
-  }
-  const toSync = [...plan.missingExtensions, ...plan.staleExtensions];
-  for (const status of toSync) {
-    const { ext } = status;
-    const srcPath = import_path3.default.join(sourceDir, ext.id);
-    const dstPath = import_path3.default.join(targetDir, ext.id);
-    if (dryRun) {
-      log(`[DRY RUN] ${status.installed ? "\u21BB" : "+"} ${ext.displayName}`);
-      continue;
-    }
-    try {
-      await import_fs_extra7.default.remove(dstPath);
-      const relTarget = import_path3.default.relative(targetDir, srcPath);
-      await import_fs_extra7.default.symlink(relTarget, dstPath);
-      if (status.installed) {
-        result.extensionsUpdated.push(ext.id);
-        log(`\u21BB ${ext.displayName} (symlinked)`);
-      } else {
-        result.extensionsAdded.push(ext.id);
-        log(`+ ${ext.displayName} (symlinked)`);
-      }
-    } catch (err) {
-      result.failed.push(ext.id);
-      log(kleur_default.red(`\u2717 ${ext.displayName}: ${err}`));
-    }
-  }
-  if (removeOrphaned && plan.orphanedExtensions.length > 0) {
-    for (const orphanId of plan.orphanedExtensions) {
-      const orphanPath = import_path3.default.join(targetDir, orphanId);
-      if (dryRun) {
-        log(kleur_default.red(`[DRY RUN] - ${orphanId} (orphaned)`));
-        continue;
-      }
-      try {
-        await import_fs_extra7.default.remove(orphanPath);
-        result.extensionsRemoved.push(orphanId);
-        log(kleur_default.red(`- ${orphanId} (orphaned)`));
-      } catch (err) {
-        result.failed.push(orphanId);
-        log(kleur_default.red(`\u2717 ${orphanId}: ${err}`));
-      }
-    }
-  }
-  for (const status of plan.missingPackages) {
-    const { pkg } = status;
-    const installArgs = isGlobal ? ["install", pkg.id] : ["install", pkg.id, "-l"];
-    if (dryRun) {
-      log(`[DRY RUN] pi ${installArgs.join(" ")}`);
-      continue;
-    }
-    try {
-      const r = (0, import_child_process2.spawnSync)("pi", installArgs, { stdio: "pipe", encoding: "utf8" });
-      if (r.status === 0) {
-        result.packagesInstalled.push(pkg.id);
-        log(`${sym.ok} ${pkg.displayName}`);
-      } else {
-        result.failed.push(pkg.id);
-        log(kleur_default.yellow(`\u26A0 ${pkg.displayName} \u2014 install failed`));
-      }
-    } catch (err) {
-      result.failed.push(pkg.id);
-      log(kleur_default.red(`\u2717 ${pkg.displayName}: ${err}`));
-    }
-  }
-  return result;
-}
-async function runPiRuntimeSync(opts = {}) {
-  const { dryRun = false, isGlobal = false, projectRoot } = opts;
-  const pkgRoot = resolvePkgRoot();
-  const sourceDir = import_path3.default.join(pkgRoot, ".xtrm", "extensions");
-  const resolvedProjectRoot = projectRoot || process.cwd();
-  const log = (msg) => console.log(kleur_default.dim(`    ${msg}`));
-  const emptyResult = {
-    extensionsAdded: [],
-    extensionsUpdated: [],
-    extensionsRemoved: [],
-    packagesInstalled: [],
-    failed: []
-  };
-  if (!await import_fs_extra7.default.pathExists(sourceDir)) {
-    console.log(kleur_default.dim("\n  Managed extensions: skipped (not bundled in npm package)\n"));
-    return emptyResult;
-  }
-  if (isGlobal) {
-    const targetDir = import_path3.default.join(PI_AGENT_DIR, "extensions");
-    const plan = await inventoryPiRuntime(sourceDir, targetDir);
-    renderPiRuntimePlan(plan);
-    if (plan.allPresent) return emptyResult;
-    return await executePiSync(plan, sourceDir, targetDir, {
-      dryRun,
-      isGlobal: true,
-      removeOrphaned: true
-    });
-  }
-  const installedPkgIds = getInstalledPiPackages();
-  const packageStatuses = [];
-  const missingPackages = [];
-  for (const pkg of MANAGED_PACKAGES) {
-    const isInstalled = installedPkgIds.includes(pkg.id);
-    const status = { pkg, installed: isInstalled };
-    packageStatuses.push(status);
-    if (!isInstalled) missingPackages.push(status);
-  }
-  console.log(kleur_default.bold("\n  Pi Runtime"));
-  console.log(kleur_default.dim("  " + "-".repeat(50)));
-  console.log(kleur_default.dim(`  Extensions: via .xtrm/extensions (settings.json)`));
-  const pkgOk = packageStatuses.filter((s) => s.installed).length;
-  console.log(kleur_default.dim(`  Packages:   ${pkgOk}/${packageStatuses.length} installed`));
-  if (missingPackages.length > 0) {
-    const names = missingPackages.map((s) => s.pkg.displayName).join(", ");
-    console.log(kleur_default.yellow(`  Missing:    ${names}`));
-  }
-  console.log(kleur_default.dim("  " + "-".repeat(50)));
-  const result = { ...emptyResult };
-  const legacyCleanup = await cleanupLegacyProjectExtensionCopies(resolvedProjectRoot, dryRun, log);
-  result.extensionsRemoved.push(...legacyCleanup.removed);
-  result.failed.push(...legacyCleanup.failed);
-  for (const status of missingPackages) {
-    const { pkg } = status;
-    if (dryRun) {
-      log(`[DRY RUN] pi install ${pkg.id} -l`);
-      continue;
-    }
-    try {
-      const r = (0, import_child_process2.spawnSync)("pi", ["install", pkg.id, "-l"], { stdio: "pipe", encoding: "utf8" });
-      if (r.status === 0) {
-        result.packagesInstalled.push(pkg.id);
-        log(`${sym.ok} ${pkg.displayName}`);
-      } else {
-        result.failed.push(pkg.id);
-        log(kleur_default.yellow(`\u26A0 ${pkg.displayName} \u2014 install failed`));
-      }
-    } catch (err) {
-      result.failed.push(pkg.id);
-      log(kleur_default.red(`\u2717 ${pkg.displayName}: ${err}`));
-    }
-  }
-  const skillsRoot = resolveSkillsRoot(resolvedProjectRoot);
-  if (await import_fs_extra7.default.pathExists(import_path3.default.join(skillsRoot, "default"))) {
-    const invariantViolations = await validateSkillsInvariants(skillsRoot);
-    if (invariantViolations.length > 0) {
-      const summary = invariantViolations.map((violation) => `${violation.code}: ${violation.message}`).join("; ");
-      throw new Error(`Skills invariants failed. ${summary}`);
-    }
-    if (!dryRun) {
-      await rebuildRuntimeActiveView("pi", skillsRoot);
-    }
-  }
-  await updatePiSettings(resolvedProjectRoot, dryRun, log);
-  await ensureCorePackageSymlink(import_path3.default.join(sourceDir, "core"), resolvedProjectRoot, dryRun, log);
-  const requiredFailed = missingPackages.filter(
-    (s) => s.pkg.required && result.failed.includes(s.pkg.id)
-  );
-  if (missingPackages.length === 0 || result.failed.length === 0) {
-    console.log(t.success("  \u2713 All required items present.\n"));
-  } else if (requiredFailed.length === 0) {
-    console.log(t.success("  \u2713 All required items present.\n"));
-  } else {
-    console.log(kleur_default.yellow("  \u26A0 Missing required items.\n"));
-  }
-  return result;
-}
-
 // src/core/skills-scaffold.ts
-var import_path4 = __toESM(require("path"), 1);
-var import_fs_extra8 = __toESM(require_lib(), 1);
 async function ensureSkillsSymlink(linkPath, symlinkTarget, label) {
-  const existing = await import_fs_extra8.default.lstat(linkPath).catch(() => null);
+  const existing = await import_fs_extra7.default.lstat(linkPath).catch(() => null);
   if (existing) {
     if (existing.isSymbolicLink()) {
-      const current = await import_fs_extra8.default.readlink(linkPath);
+      const current = await import_fs_extra7.default.readlink(linkPath);
       if (current === symlinkTarget) {
         console.log(kleur_default.dim(`  \u2713 ${label} symlink already in place`));
         return;
       }
-      await import_fs_extra8.default.remove(linkPath);
+      await import_fs_extra7.default.remove(linkPath);
     } else {
       if (label === ".claude/skills") {
         console.log(kleur_default.yellow("  \u26A0 .claude/skills is a runtime-managed read-only view; direct writes are unsupported."));
         console.log(kleur_default.yellow("    Move custom skills to .xtrm/skills/default or .xtrm/skills/{optional,user}/packs/* and rebuild."));
       }
-      await import_fs_extra8.default.remove(linkPath);
+      await import_fs_extra7.default.remove(linkPath);
       console.log(kleur_default.yellow(`  \u26A0 ${label} was a real path \u2014 replaced with managed symlink`));
     }
   }
-  await import_fs_extra8.default.mkdirp(import_path4.default.dirname(linkPath));
-  await import_fs_extra8.default.symlink(symlinkTarget, linkPath);
+  await import_fs_extra7.default.mkdirp(import_path3.default.dirname(linkPath));
+  await import_fs_extra7.default.symlink(symlinkTarget, linkPath);
   console.log(`${kleur_default.green("  \u2713")} ${label} \u2192 ${symlinkTarget}`);
 }
 async function ensureAgentsSkillsSymlink(projectRoot) {
   const skillsRoot = resolveSkillsRoot(projectRoot);
-  if (!await import_fs_extra8.default.pathExists(import_path4.default.join(skillsRoot, "default"))) {
+  if (!await import_fs_extra7.default.pathExists(import_path3.default.join(skillsRoot, "default"))) {
     return {
       activatedClaudeSkills: 0,
       activatedPiSkills: 0
@@ -44439,12 +44004,12 @@ async function ensureAgentsSkillsSymlink(projectRoot) {
   const activatedClaudeSkills = materializedViews.find((view) => view.runtime === "claude")?.discoveredSkillCount ?? 0;
   const activatedPiSkills = materializedViews.find((view) => view.runtime === "pi")?.discoveredSkillCount ?? 0;
   await ensureSkillsSymlink(
-    import_path4.default.join(projectRoot, ".claude", "skills"),
-    import_path4.default.join("..", ".xtrm", "skills", "active", "claude"),
+    import_path3.default.join(projectRoot, ".claude", "skills"),
+    import_path3.default.join("..", ".xtrm", "skills", "active", "claude"),
     ".claude/skills"
   );
-  const agentsSkillsPath = import_path4.default.join(projectRoot, ".agents", "skills");
-  if (await import_fs_extra8.default.pathExists(agentsSkillsPath)) {
+  const agentsSkillsPath = import_path3.default.join(projectRoot, ".agents", "skills");
+  if (await import_fs_extra7.default.pathExists(agentsSkillsPath)) {
     console.log(kleur_default.dim("  \u25CB .agents/skills is deprecated; runtime skills are generated under .xtrm/skills/active/*"));
   }
   return {
@@ -44567,31 +44132,6 @@ async function launchWorktreeSession(opts) {
   console.log(kleur_default.green(`
   \u2713 Worktree ready \u2014 launching ${runtime}...
 `));
-  if (runtime === "pi") {
-    const projectPiDir = import_node_path5.default.join(mainRepoRoot, ".pi");
-    const worktreePiDir = import_node_path5.default.join(worktreePath, ".pi");
-    if ((0, import_node_fs.existsSync)(projectPiDir) && !(0, import_node_fs.existsSync)(worktreePiDir)) {
-      try {
-        (0, import_node_fs.symlinkSync)(projectPiDir, worktreePiDir);
-      } catch {
-      }
-    }
-    const projectPiNpmDir = import_node_path5.default.join(projectPiDir, "npm");
-    const worktreePiNpmDir = import_node_path5.default.join(worktreePiDir, "npm");
-    if ((0, import_node_fs.existsSync)(projectPiNpmDir) && !(0, import_node_fs.existsSync)(worktreePiNpmDir)) {
-      try {
-        (0, import_node_fs.symlinkSync)(projectPiNpmDir, worktreePiNpmDir);
-      } catch {
-      }
-    }
-    const coreExtDir = import_node_path5.default.join(worktreePath, ".xtrm", "extensions", "core");
-    try {
-      await ensureCorePackageSymlink(coreExtDir, worktreePath, false);
-    } catch (error48) {
-      const message = error48 instanceof Error ? error48.message : String(error48);
-      console.log(kleur_default.dim(`  warning: could not ensure @xtrm/pi-core symlink (${message})`));
-    }
-  }
   if (runtime === "claude") {
     const claudeDir = import_node_path5.default.join(worktreePath, ".claude");
     try {
@@ -44669,7 +44209,7 @@ async function confirmDestructiveAction(opts) {
 }
 
 // src/core/machine-bootstrap.ts
-var import_child_process3 = require("child_process");
+var import_child_process2 = require("child_process");
 var OFFICIAL_CLAUDE_PLUGINS = ["serena", "context7"];
 var OFFICIAL_MARKETPLACE = "claude-plugins-official";
 var MANAGED_DEPS = [
@@ -44775,7 +44315,7 @@ var MANAGED_DEPS = [
   }
 ];
 function checkDep(dep) {
-  const result = (0, import_child_process3.spawnSync)(dep.cli, [dep.versionFlag], {
+  const result = (0, import_child_process2.spawnSync)(dep.cli, [dep.versionFlag], {
     encoding: "utf8",
     stdio: "pipe",
     timeout: 5e3
@@ -44862,7 +44402,7 @@ function executeBootstrap(plan, opts = {}) {
     for (const step of steps) {
       const cmd = step.sudo && process.platform !== "darwin" ? "sudo" : step.cmd;
       const args = step.sudo && process.platform !== "darwin" ? [step.cmd, ...step.args] : step.args;
-      const r = (0, import_child_process3.spawnSync)(cmd, args, { stdio: "inherit" });
+      const r = (0, import_child_process2.spawnSync)(cmd, args, { stdio: "inherit" });
       if (r.status !== 0) {
         ok = false;
         break;
@@ -44913,7 +44453,7 @@ function normalizePluginName(name) {
   return atIndex === -1 ? trimmed : trimmed.slice(0, atIndex);
 }
 function readInstalledOfficialPlugins() {
-  const listResult = (0, import_child_process3.spawnSync)("claude", ["plugin", "list", "--json"], {
+  const listResult = (0, import_child_process2.spawnSync)("claude", ["plugin", "list", "--json"], {
     encoding: "utf8",
     stdio: "pipe",
     timeout: 1e4
@@ -44941,14 +44481,14 @@ function readInstalledOfficialPlugins() {
   return installedNames;
 }
 function ensureOfficialMarketplace() {
-  const listResult = (0, import_child_process3.spawnSync)("claude", ["plugin", "marketplace", "list"], {
+  const listResult = (0, import_child_process2.spawnSync)("claude", ["plugin", "marketplace", "list"], {
     encoding: "utf8",
     stdio: "pipe",
     timeout: 1e4
   });
   const output = listResult.stdout ?? "";
   if (output.includes(OFFICIAL_MARKETPLACE)) return;
-  (0, import_child_process3.spawnSync)("claude", [
+  (0, import_child_process2.spawnSync)("claude", [
     "plugin",
     "marketplace",
     "add",
@@ -44956,12 +44496,12 @@ function ensureOfficialMarketplace() {
   ], { stdio: "inherit", timeout: 12e4 });
 }
 function tryInstallOfficialPlugin(pluginName) {
-  const directInstall = (0, import_child_process3.spawnSync)("claude", ["plugin", "install", pluginName, "--scope", "user"], { stdio: "inherit" });
+  const directInstall = (0, import_child_process2.spawnSync)("claude", ["plugin", "install", pluginName, "--scope", "user"], { stdio: "inherit" });
   if (directInstall.status === 0) {
     return true;
   }
   const marketplaceQualified = `${pluginName}@${OFFICIAL_MARKETPLACE}`;
-  const marketplaceInstall = (0, import_child_process3.spawnSync)("claude", ["plugin", "install", marketplaceQualified, "--scope", "user"], { stdio: "inherit" });
+  const marketplaceInstall = (0, import_child_process2.spawnSync)("claude", ["plugin", "install", marketplaceQualified, "--scope", "user"], { stdio: "inherit" });
   return marketplaceInstall.status === 0;
 }
 function ensureOfficialPlugins(dryRun) {
@@ -45020,9 +44560,9 @@ function getProjectSettingsPath(repoRoot) {
   return import_node_path6.default.join(repoRoot, ".claude", "settings.json");
 }
 function hasXtrmHookWiring(settingsPath) {
-  if (!import_fs_extra9.default.existsSync(settingsPath)) return false;
+  if (!import_fs_extra8.default.existsSync(settingsPath)) return false;
   try {
-    const data = import_fs_extra9.default.readJsonSync(settingsPath);
+    const data = import_fs_extra8.default.readJsonSync(settingsPath);
     const groups = Object.values(data.hooks ?? {});
     for (const wrappers of groups) {
       for (const wrapper of wrappers) {
@@ -45136,6 +44676,682 @@ var import_fs_extra11 = __toESM(require_lib(), 1);
 var import_path5 = __toESM(require("path"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_os2 = require("os");
+
+// src/core/pi-runtime.ts
+var import_child_process3 = require("child_process");
+var import_fs_extra9 = __toESM(require_lib(), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_node_os = require("os");
+function resolvePkgRoot() {
+  const candidates = [
+    import_path4.default.resolve(__dirname, "../.."),
+    import_path4.default.resolve(__dirname, "../../..")
+  ];
+  for (const c of candidates) {
+    if (import_fs_extra9.default.existsSync(import_path4.default.join(c, ".xtrm", "extensions"))) return c;
+  }
+  return candidates[0];
+}
+var PI_AGENT_DIR = process.env.PI_AGENT_DIR || import_path4.default.join((0, import_node_os.homedir)(), ".pi", "agent");
+var PI_MCP_ADAPTER_OVERRIDE_DIR = import_path4.default.join(PI_AGENT_DIR, "extensions", "pi-mcp-adapter");
+var PI_MCP_ADAPTER_REQUIRED_ENTRY = "commands.js";
+var PROJECT_EXTENSIONS_ENTRY = "../.xtrm/extensions";
+var PROJECT_SKILLS_ENTRY = "../.xtrm/skills/active/pi";
+var MANAGED_EXTENSIONS = [
+  { id: "core", displayName: "@xtrm/pi-core", isLibrary: true, required: true },
+  { id: "auto-session-name", displayName: "auto-session-name", required: false },
+  { id: "auto-update", displayName: "auto-update", required: false },
+  { id: "beads", displayName: "beads", required: true },
+  { id: "compact-header", displayName: "compact-header", required: false },
+  { id: "custom-footer", displayName: "custom-footer", required: true },
+  { id: "custom-provider-qwen-cli", displayName: "custom-provider-qwen-cli", required: false },
+  { id: "git-checkpoint", displayName: "git-checkpoint", required: false },
+  { id: "lsp-bootstrap", displayName: "lsp-bootstrap", required: false },
+  { id: "pi-serena-compact", displayName: "pi-serena-compact", required: false },
+  { id: "quality-gates", displayName: "quality-gates", required: true },
+  { id: "service-skills", displayName: "service-skills", required: false },
+  { id: "session-flow", displayName: "session-flow", required: true },
+  { id: "xtrm-loader", displayName: "xtrm-loader", required: true },
+  { id: "xtrm-ui", displayName: "xtrm-ui", required: true }
+];
+var MANAGED_PACKAGES = [
+  { id: "npm:pi-gitnexus", displayName: "pi-gitnexus", required: true },
+  { id: "npm:pi-serena-tools", displayName: "pi-serena-tools", required: true },
+  { id: "npm:@zenobius/pi-worktrees", displayName: "pi-worktrees", required: true },
+  { id: "npm:@robhowley/pi-structured-return", displayName: "pi-structured-return", required: true },
+  { id: "npm:@aliou/pi-guardrails", displayName: "pi-guardrails", required: false },
+  { id: "npm:@aliou/pi-processes", displayName: "pi-processes", required: true }
+];
+var ALWAYS_GLOBAL_INSTALL_PACKAGE_IDS = /* @__PURE__ */ new Set([
+  "npm:pi-gitnexus",
+  "npm:pi-serena-tools"
+]);
+function getInstalledPiPackages() {
+  const result = (0, import_child_process3.spawnSync)("pi", ["list"], { encoding: "utf8", stdio: "pipe" });
+  if (result.status !== 0) return [];
+  const output = result.stdout;
+  const packages = [];
+  for (const line of output.split("\n")) {
+    const match = line.match(/^\s+(npm:[\w\-/@]+)/);
+    if (match) packages.push(match[1]);
+  }
+  return packages.sort();
+}
+async function listInstalledExtensions(targetDir) {
+  if (!await import_fs_extra9.default.pathExists(targetDir)) return [];
+  const entries = await import_fs_extra9.default.readdir(targetDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name).sort();
+}
+async function inventoryPiRuntime(sourceDir, targetDir) {
+  const installedExtNames = await listInstalledExtensions(targetDir);
+  const extensionStatuses = [];
+  const missingExtensions = [];
+  const staleExtensions = [];
+  const orphanedExtensions = [];
+  for (const ext of MANAGED_EXTENSIONS) {
+    const srcPath = import_path4.default.join(sourceDir, ext.id);
+    const dstPath = import_path4.default.join(targetDir, ext.id);
+    const srcExists = await import_fs_extra9.default.pathExists(srcPath);
+    const dstExists = await import_fs_extra9.default.pathExists(dstPath);
+    if (!srcExists) {
+      continue;
+    }
+    if (!dstExists) {
+      const status2 = { ext, installed: false };
+      extensionStatuses.push(status2);
+      missingExtensions.push(status2);
+      continue;
+    }
+    let isStale = false;
+    if (srcPath !== dstPath) {
+      const dstStat = await import_fs_extra9.default.lstat(dstPath);
+      if (dstStat.isSymbolicLink()) {
+        const linkTarget = await import_fs_extra9.default.readlink(dstPath);
+        const resolvedTarget = import_path4.default.resolve(import_path4.default.dirname(dstPath), linkTarget);
+        isStale = resolvedTarget !== import_path4.default.resolve(srcPath);
+      } else {
+        isStale = true;
+      }
+    }
+    const status = {
+      ext,
+      installed: true,
+      stale: isStale
+    };
+    extensionStatuses.push(status);
+    if (isStale) {
+      staleExtensions.push(status);
+    }
+  }
+  const managedIds = new Set(MANAGED_EXTENSIONS.map((e) => e.id));
+  for (const name of installedExtNames) {
+    if (!managedIds.has(name)) {
+      orphanedExtensions.push(name);
+    }
+  }
+  const installedPkgIds = getInstalledPiPackages();
+  const packageStatuses = [];
+  const missingPackages = [];
+  for (const pkg of MANAGED_PACKAGES) {
+    const isInstalled = installedPkgIds.includes(pkg.id);
+    const status = { pkg, installed: isInstalled };
+    packageStatuses.push(status);
+    if (!isInstalled) {
+      missingPackages.push(status);
+    }
+  }
+  const allRequiredPresent = missingExtensions.every((s) => !s.ext.required) && staleExtensions.every((s) => !s.ext.required) && missingPackages.every((s) => !s.pkg.required);
+  const allPresent = missingExtensions.length === 0 && staleExtensions.length === 0 && orphanedExtensions.length === 0 && missingPackages.length === 0;
+  return {
+    extensions: extensionStatuses,
+    packages: packageStatuses,
+    missingExtensions,
+    staleExtensions,
+    orphanedExtensions,
+    missingPackages,
+    allRequiredPresent,
+    allPresent
+  };
+}
+function renderPiRuntimePlan(plan) {
+  console.log(kleur_default.bold("\n  Pi Runtime"));
+  console.log(kleur_default.dim("  " + "-".repeat(50)));
+  const extTotal = plan.extensions.length;
+  const extOk = plan.extensions.filter((s) => s.installed && !s.stale).length;
+  console.log(kleur_default.dim(`  Extensions: ${extOk}/${extTotal} up-to-date`));
+  if (plan.missingExtensions.length > 0) {
+    const names = plan.missingExtensions.map((s) => s.ext.displayName).join(", ");
+    console.log(kleur_default.yellow(`  Missing:    ${names}`));
+  }
+  if (plan.staleExtensions.length > 0) {
+    const names = plan.staleExtensions.map((s) => s.ext.displayName).join(", ");
+    console.log(kleur_default.yellow(`  Stale:      ${names}`));
+  }
+  if (plan.orphanedExtensions.length > 0) {
+    const names = plan.orphanedExtensions.join(", ");
+    console.log(kleur_default.red(`  Orphaned:   ${names} (will remove)`));
+  }
+  const pkgTotal = plan.packages.length;
+  const pkgOk = plan.packages.filter((s) => s.installed).length;
+  console.log(kleur_default.dim(`  Packages:   ${pkgOk}/${pkgTotal} installed`));
+  if (plan.missingPackages.length > 0) {
+    const names = plan.missingPackages.map((s) => s.pkg.displayName).join(", ");
+    console.log(kleur_default.yellow(`  Missing:    ${names}`));
+  }
+  console.log(kleur_default.dim("  " + "-".repeat(50)));
+  if (plan.allPresent) {
+    console.log(t.success("  \u2713 All extensions and packages present.\n"));
+  } else if (plan.allRequiredPresent) {
+    console.log(t.success("  \u2713 All required items present."));
+    const optionalMissing = [
+      ...plan.missingExtensions.filter((s) => !s.ext.required),
+      ...plan.missingPackages.filter((s) => !s.pkg.required)
+    ];
+    if (optionalMissing.length > 0) {
+      const names = optionalMissing.map(
+        (s) => "ext" in s ? s.ext.displayName : s.pkg.displayName
+      ).join(", ");
+      console.log(kleur_default.dim(`  \u25CB Optional not installed: ${names}
+`));
+    } else {
+      console.log("");
+    }
+  } else {
+    console.log(kleur_default.yellow("  \u26A0 Missing required items.\n"));
+  }
+}
+function mergePiSyncResults(base, incoming) {
+  return {
+    extensionsAdded: [...base.extensionsAdded, ...incoming.extensionsAdded],
+    extensionsUpdated: [...base.extensionsUpdated, ...incoming.extensionsUpdated],
+    extensionsRemoved: [...base.extensionsRemoved, ...incoming.extensionsRemoved],
+    packagesInstalled: [...base.packagesInstalled, ...incoming.packagesInstalled],
+    failed: [...base.failed, ...incoming.failed]
+  };
+}
+function parseNpmPackageName(piPackageId) {
+  if (!piPackageId.startsWith("npm:")) return null;
+  const npmPackageName = piPackageId.slice(4).trim();
+  return npmPackageName.length > 0 ? npmPackageName : null;
+}
+async function isPackagePresentInPiAgent(agentDir, piPackageId) {
+  const npmPackageName = parseNpmPackageName(piPackageId);
+  if (!npmPackageName) return false;
+  const packageDir = import_path4.default.join(agentDir, "npm", "node_modules", npmPackageName);
+  return import_fs_extra9.default.pathExists(packageDir);
+}
+async function ensureAlwaysGlobalPiPackages(dryRun, log, agentDir = PI_AGENT_DIR, installRunner = (piPackageId) => {
+  const installResult = (0, import_child_process3.spawnSync)("pi", ["install", piPackageId], { stdio: "pipe", encoding: "utf8" });
+  return installResult.status;
+}) {
+  const installed = [];
+  const failed = [];
+  const packagesToEnsure = MANAGED_PACKAGES.filter((pkg) => ALWAYS_GLOBAL_INSTALL_PACKAGE_IDS.has(pkg.id));
+  for (const pkg of packagesToEnsure) {
+    if (await isPackagePresentInPiAgent(agentDir, pkg.id)) {
+      continue;
+    }
+    if (dryRun) {
+      log?.(`[DRY RUN] pi install ${pkg.id}`);
+      continue;
+    }
+    const installStatus = installRunner(pkg.id);
+    if (installStatus === 0) {
+      installed.push(pkg.id);
+      log?.(`${sym.ok} ${pkg.displayName} (global)`);
+      continue;
+    }
+    failed.push(pkg.id);
+    log?.(kleur_default.yellow(`\u26A0 ${pkg.displayName} \u2014 global install failed`));
+  }
+  return { installed, failed };
+}
+async function ensureCorePackageSymlink(coreSrcDir, projectRoot, dryRun, log) {
+  if (!await import_fs_extra9.default.pathExists(coreSrcDir)) return "missing-source";
+  const extensionsDir = import_path4.default.join(projectRoot, ".xtrm", "extensions");
+  const nodeModulesDir = import_path4.default.join(extensionsDir, "node_modules", "@xtrm");
+  const symlinkPath = import_path4.default.join(nodeModulesDir, "pi-core");
+  const expectedTarget = import_path4.default.resolve(coreSrcDir);
+  const existing = await import_fs_extra9.default.lstat(symlinkPath).catch(() => null);
+  if (existing) {
+    if (existing.isSymbolicLink()) {
+      const currentLinkTarget = await import_fs_extra9.default.readlink(symlinkPath);
+      const resolvedTarget = import_path4.default.resolve(import_path4.default.dirname(symlinkPath), currentLinkTarget);
+      if (resolvedTarget === expectedTarget) {
+        return "ok";
+      }
+    }
+    if (dryRun) {
+      log?.(kleur_default.dim("[DRY RUN] would repair @xtrm/pi-core symlink target"));
+      return "would-repair";
+    }
+    await import_fs_extra9.default.remove(symlinkPath);
+    await import_fs_extra9.default.ensureDir(nodeModulesDir);
+    const relTarget2 = import_path4.default.relative(nodeModulesDir, coreSrcDir);
+    await import_fs_extra9.default.symlink(relTarget2, symlinkPath);
+    log?.(kleur_default.dim("Repaired @xtrm/pi-core symlink \u2192 .xtrm/extensions/node_modules/@xtrm/pi-core"));
+    return "repaired";
+  }
+  if (dryRun) {
+    log?.(kleur_default.dim("[DRY RUN] would create @xtrm/pi-core symlink"));
+    return "would-create";
+  }
+  await import_fs_extra9.default.ensureDir(nodeModulesDir);
+  const relTarget = import_path4.default.relative(nodeModulesDir, coreSrcDir);
+  await import_fs_extra9.default.symlink(relTarget, symlinkPath);
+  log?.(kleur_default.dim("Created @xtrm/pi-core symlink \u2192 .xtrm/extensions/node_modules/@xtrm/pi-core"));
+  return "created";
+}
+async function remediateStalePiMcpAdapterOverride(dryRun, log) {
+  const stat = await import_fs_extra9.default.lstat(PI_MCP_ADAPTER_OVERRIDE_DIR).catch(() => null);
+  if (!stat) {
+    return {
+      path: PI_MCP_ADAPTER_OVERRIDE_DIR,
+      found: false,
+      stale: false,
+      remediated: false
+    };
+  }
+  if (stat.isSymbolicLink()) {
+    return {
+      path: PI_MCP_ADAPTER_OVERRIDE_DIR,
+      found: true,
+      stale: false,
+      remediated: false
+    };
+  }
+  const hasRequiredEntry = await import_fs_extra9.default.pathExists(import_path4.default.join(PI_MCP_ADAPTER_OVERRIDE_DIR, PI_MCP_ADAPTER_REQUIRED_ENTRY));
+  if (stat.isDirectory() && hasRequiredEntry) {
+    return {
+      path: PI_MCP_ADAPTER_OVERRIDE_DIR,
+      found: true,
+      stale: false,
+      remediated: false
+    };
+  }
+  const reason = stat.isDirectory() ? `missing ${PI_MCP_ADAPTER_REQUIRED_ENTRY}` : "not a directory/symlink";
+  if (dryRun) {
+    log?.(kleur_default.dim(`[DRY RUN] would remove stale pi-mcp-adapter override (${reason})`));
+    return {
+      path: PI_MCP_ADAPTER_OVERRIDE_DIR,
+      found: true,
+      stale: true,
+      remediated: false,
+      reason
+    };
+  }
+  await import_fs_extra9.default.remove(PI_MCP_ADAPTER_OVERRIDE_DIR);
+  log?.(kleur_default.dim(`Removed stale pi-mcp-adapter override (${reason})`));
+  return {
+    path: PI_MCP_ADAPTER_OVERRIDE_DIR,
+    found: true,
+    stale: true,
+    remediated: true,
+    reason
+  };
+}
+async function runPiLaunchPreflight(projectRoot, dryRun, log) {
+  const staleOverride = await remediateStalePiMcpAdapterOverride(dryRun, log);
+  const coreSymlinkStatus = await ensureCorePackageSymlink(
+    import_path4.default.join(projectRoot, ".xtrm", "extensions", "core"),
+    projectRoot,
+    dryRun,
+    log
+  );
+  return {
+    coreSymlinkStatus,
+    staleOverride
+  };
+}
+function isXtrmExtensionsSetting(entry) {
+  const normalizedEntry = entry.replaceAll("\\", "/").replace(/\/$/, "");
+  return normalizedEntry === PROJECT_EXTENSIONS_ENTRY || normalizedEntry === ".xtrm/extensions";
+}
+async function cleanupLegacyProjectExtensionCopies(projectRoot, dryRun, log) {
+  const piSettingsPath = import_path4.default.join(projectRoot, ".pi", "settings.json");
+  let existingSettings = {};
+  try {
+    existingSettings = await import_fs_extra9.default.readJson(piSettingsPath);
+  } catch {
+    return { removed: [], failed: [] };
+  }
+  const pointsToXtrmExtensions = (existingSettings.extensions ?? []).some(isXtrmExtensionsSetting);
+  if (!pointsToXtrmExtensions) return { removed: [], failed: [] };
+  const legacyExtensionsDir = import_path4.default.join(projectRoot, ".pi", "extensions");
+  if (!await import_fs_extra9.default.pathExists(legacyExtensionsDir)) return { removed: [], failed: [] };
+  const removed = [];
+  const failed = [];
+  for (const ext of MANAGED_EXTENSIONS) {
+    const legacyExtPath = import_path4.default.join(legacyExtensionsDir, ext.id);
+    const legacyStat = await import_fs_extra9.default.lstat(legacyExtPath).catch(() => null);
+    if (!legacyStat || legacyStat.isSymbolicLink() || !legacyStat.isDirectory()) {
+      continue;
+    }
+    if (dryRun) {
+      log?.(kleur_default.dim(`[DRY RUN] - .pi/extensions/${ext.id} (legacy copy)`));
+      continue;
+    }
+    try {
+      await import_fs_extra9.default.remove(legacyExtPath);
+      removed.push(ext.id);
+      log?.(kleur_default.dim(`Removed legacy .pi/extensions/${ext.id}`));
+    } catch (err) {
+      failed.push(ext.id);
+      log?.(kleur_default.red(`\u2717 Failed to remove legacy .pi/extensions/${ext.id}: ${err}`));
+    }
+  }
+  return { removed, failed };
+}
+async function updatePiSettings(projectRoot, dryRun, log) {
+  const piSettingsPath = import_path4.default.join(projectRoot, ".pi", "settings.json");
+  if (dryRun) {
+    log?.(kleur_default.dim(`[DRY RUN] would update .pi/settings.json`));
+    return;
+  }
+  let existingSettings = {};
+  try {
+    existingSettings = await import_fs_extra9.default.readJson(piSettingsPath);
+  } catch {
+  }
+  const existingPackages = (existingSettings.packages ?? []).filter(
+    (p) => !p.startsWith("./extensions/")
+  );
+  await import_fs_extra9.default.ensureDir(import_path4.default.join(projectRoot, ".pi"));
+  await import_fs_extra9.default.writeJson(piSettingsPath, {
+    ...existingSettings,
+    extensions: [],
+    // Empty = Pi uses global ~/.pi/agent/extensions/
+    skills: [PROJECT_SKILLS_ENTRY],
+    packages: []
+    // Empty = packages installed globally at ~/.pi/agent/settings.json
+  }, { spaces: 2 });
+  log?.(kleur_default.dim(`Updated .pi/settings.json \u2192 global extensions + packages + .xtrm/skills/active/pi`));
+}
+async function executePiSync(plan, sourceDir, targetDir, opts = {}) {
+  const {
+    dryRun = false,
+    isGlobal = false,
+    projectRoot,
+    removeOrphaned = true,
+    log = (msg) => console.log(kleur_default.dim(`    ${msg}`))
+  } = opts;
+  const result = {
+    extensionsAdded: [],
+    extensionsUpdated: [],
+    extensionsRemoved: [],
+    packagesInstalled: [],
+    failed: []
+  };
+  if (!dryRun) {
+    await import_fs_extra9.default.ensureDir(targetDir);
+  }
+  const toSync = [...plan.missingExtensions, ...plan.staleExtensions];
+  for (const status of toSync) {
+    const { ext } = status;
+    const srcPath = import_path4.default.join(sourceDir, ext.id);
+    const dstPath = import_path4.default.join(targetDir, ext.id);
+    if (dryRun) {
+      log(`[DRY RUN] ${status.installed ? "\u21BB" : "+"} ${ext.displayName}`);
+      continue;
+    }
+    try {
+      await import_fs_extra9.default.remove(dstPath);
+      const relTarget = import_path4.default.relative(targetDir, srcPath);
+      await import_fs_extra9.default.symlink(relTarget, dstPath);
+      if (status.installed) {
+        result.extensionsUpdated.push(ext.id);
+        log(`\u21BB ${ext.displayName} (symlinked)`);
+      } else {
+        result.extensionsAdded.push(ext.id);
+        log(`+ ${ext.displayName} (symlinked)`);
+      }
+    } catch (err) {
+      result.failed.push(ext.id);
+      log(kleur_default.red(`\u2717 ${ext.displayName}: ${err}`));
+    }
+  }
+  if (removeOrphaned && plan.orphanedExtensions.length > 0) {
+    for (const orphanId of plan.orphanedExtensions) {
+      const orphanPath = import_path4.default.join(targetDir, orphanId);
+      if (dryRun) {
+        log(kleur_default.red(`[DRY RUN] - ${orphanId} (orphaned)`));
+        continue;
+      }
+      try {
+        await import_fs_extra9.default.remove(orphanPath);
+        result.extensionsRemoved.push(orphanId);
+        log(kleur_default.red(`- ${orphanId} (orphaned)`));
+      } catch (err) {
+        result.failed.push(orphanId);
+        log(kleur_default.red(`\u2717 ${orphanId}: ${err}`));
+      }
+    }
+  }
+  for (const status of plan.missingPackages) {
+    const { pkg } = status;
+    const installArgs = ["install", pkg.id];
+    if (dryRun) {
+      log(`[DRY RUN] pi ${installArgs.join(" ")}`);
+      continue;
+    }
+    try {
+      const r = (0, import_child_process3.spawnSync)("pi", installArgs, { stdio: "pipe", encoding: "utf8" });
+      if (r.status === 0) {
+        result.packagesInstalled.push(pkg.id);
+        log(`${sym.ok} ${pkg.displayName}`);
+      } else {
+        result.failed.push(pkg.id);
+        log(kleur_default.yellow(`\u26A0 ${pkg.displayName} \u2014 install failed`));
+      }
+    } catch (err) {
+      result.failed.push(pkg.id);
+      log(kleur_default.red(`\u2717 ${pkg.displayName}: ${err}`));
+    }
+  }
+  return result;
+}
+var EXTENSION_SOURCE_DIR = "ext-src";
+async function linkExtensionsToGlobal(repoRoot, dryRun = false, log = (msg) => console.log(kleur_default.dim(`    ${msg}`))) {
+  const globalExtDir = import_path4.default.join(PI_AGENT_DIR, "extensions");
+  const repoExtDir = import_path4.default.join(repoRoot, ".xtrm", EXTENSION_SOURCE_DIR);
+  const linked = [];
+  const failed = [];
+  if (!await import_fs_extra9.default.pathExists(repoExtDir)) {
+    log("No .xtrm/ext-src/ found \u2014 skipping global link");
+    return { linked, failed };
+  }
+  if (dryRun) {
+    log("[DRY RUN] would create extension symlinks in ~/.pi/agent/extensions/");
+    return { linked, failed };
+  }
+  await import_fs_extra9.default.ensureDir(globalExtDir);
+  const coreNodeModulesDir = import_path4.default.join(globalExtDir, "node_modules", "@xtrm");
+  const coreSymlinkPath = import_path4.default.join(coreNodeModulesDir, "pi-core");
+  const coreRelativeTarget = import_path4.default.join("..", "..", "core");
+  try {
+    await import_fs_extra9.default.ensureDir(coreNodeModulesDir);
+    const existing = await import_fs_extra9.default.lstat(coreSymlinkPath).catch(() => null);
+    if (existing) await import_fs_extra9.default.remove(coreSymlinkPath);
+    await import_fs_extra9.default.symlink(coreRelativeTarget, coreSymlinkPath);
+    log("\u2713 @xtrm/pi-core \u2192 global node_modules");
+  } catch (err) {
+    log(kleur_default.yellow(`\u26A0 @xtrm/pi-core symlink: ${err}`));
+  }
+  const entries = await import_fs_extra9.default.readdir(repoExtDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === "node_modules") continue;
+    const extPath = import_path4.default.join(repoExtDir, entry.name);
+    const globalLink = import_path4.default.join(globalExtDir, entry.name);
+    try {
+      const existing = await import_fs_extra9.default.lstat(globalLink).catch(() => null);
+      if (existing) {
+        if (existing.isSymbolicLink()) {
+          const currentTarget = await import_fs_extra9.default.readlink(globalLink);
+          const resolvedTarget = import_path4.default.resolve(import_path4.default.dirname(globalLink), currentTarget);
+          if (resolvedTarget === import_path4.default.resolve(extPath)) {
+            continue;
+          }
+        }
+        await import_fs_extra9.default.remove(globalLink);
+      }
+      await import_fs_extra9.default.symlink(extPath, globalLink);
+      linked.push(entry.name);
+      log(`\u2713 ${entry.name} \u2192 .xtrm/${EXTENSION_SOURCE_DIR}/${entry.name}`);
+    } catch (err) {
+      failed.push(entry.name);
+      log(kleur_default.red(`\u2717 ${entry.name}: ${err}`));
+    }
+  }
+  return { linked, failed };
+}
+async function ensureNpmPackageExtensionSymlinks(log) {
+  const os9 = require("os");
+  const homeDir = os9.homedir();
+  const extensionsDir = import_path4.default.join(homeDir, ".pi", "agent", "extensions");
+  await import_fs_extra9.default.ensureDir(extensionsDir);
+  const npmPrefix = (0, import_child_process3.spawnSync)("npm", ["prefix", "-g"], { encoding: "utf8" }).stdout.trim();
+  const globalNodeModules = import_path4.default.join(npmPrefix, "lib", "node_modules");
+  const npmPackages = [
+    { packageName: "pi-gitnexus", symlinkName: "gitnexus" },
+    { packageName: "pi-serena-tools", symlinkName: "serena" }
+  ];
+  for (const { packageName, symlinkName } of npmPackages) {
+    const packagePath = import_path4.default.join(globalNodeModules, packageName);
+    const symlinkPath = import_path4.default.join(extensionsDir, symlinkName);
+    const packageExists = await import_fs_extra9.default.pathExists(packagePath);
+    if (!packageExists) {
+      log?.(kleur_default.yellow(`  \u26A0 ${packageName} not found in ${globalNodeModules}, skipping symlink`));
+      continue;
+    }
+    const symlinkExists = await import_fs_extra9.default.lstat(symlinkPath).catch(() => null);
+    if (symlinkExists?.isSymbolicLink()) {
+      const currentTarget = await import_fs_extra9.default.readlink(symlinkPath);
+      const resolvedTarget = import_path4.default.resolve(extensionsDir, currentTarget);
+      if (resolvedTarget === packagePath) {
+        log?.(kleur_default.dim(`  \u2713 ${symlinkName} symlink already correct`));
+        continue;
+      }
+      log?.(kleur_default.dim(`  Removing stale ${symlinkName} symlink`));
+      await import_fs_extra9.default.remove(symlinkPath);
+    } else if (symlinkExists) {
+      log?.(kleur_default.dim(`  Removing stale ${symlinkName} (not a symlink)`));
+      await import_fs_extra9.default.remove(symlinkPath);
+    }
+    const relativeTarget = import_path4.default.relative(extensionsDir, packagePath);
+    await import_fs_extra9.default.symlink(relativeTarget, symlinkPath);
+    log?.(kleur_default.dim(`  Created ${symlinkName} symlink \u2192 ${relativeTarget}`));
+  }
+}
+async function runPiRuntimeSync(opts = {}) {
+  const { dryRun = false, isGlobal = false, projectRoot } = opts;
+  const pkgRoot = resolvePkgRoot();
+  const sourceDir = import_path4.default.join(pkgRoot, ".xtrm", "extensions");
+  const resolvedProjectRoot = projectRoot || process.cwd();
+  const log = (msg) => console.log(kleur_default.dim(`    ${msg}`));
+  const emptyResult = {
+    extensionsAdded: [],
+    extensionsUpdated: [],
+    extensionsRemoved: [],
+    packagesInstalled: [],
+    failed: []
+  };
+  const result = { ...emptyResult };
+  if (!await import_fs_extra9.default.pathExists(sourceDir)) {
+    console.log(kleur_default.dim("\n  Managed extensions: skipped (not bundled in npm package)\n"));
+    return result;
+  }
+  const preflight = await runPiLaunchPreflight(resolvedProjectRoot, dryRun, log);
+  if (preflight.staleOverride.remediated) {
+    result.extensionsRemoved.push("pi-mcp-adapter");
+  }
+  if (isGlobal) {
+    const targetDir = import_path4.default.join(PI_AGENT_DIR, "extensions");
+    const plan = await inventoryPiRuntime(sourceDir, targetDir);
+    renderPiRuntimePlan(plan);
+    if (plan.allPresent) return result;
+    const synced = await executePiSync(plan, sourceDir, targetDir, {
+      dryRun,
+      isGlobal: true,
+      removeOrphaned: true
+    });
+    return mergePiSyncResults(result, synced);
+  }
+  const linkResult = await linkExtensionsToGlobal(resolvedProjectRoot, dryRun, log);
+  result.extensionsAdded.push(...linkResult.linked);
+  result.failed.push(...linkResult.failed);
+  await ensureNpmPackageExtensionSymlinks(log);
+  const installedPkgIds = getInstalledPiPackages();
+  const packageStatuses = [];
+  const missingPackages = [];
+  for (const pkg of MANAGED_PACKAGES) {
+    const isInstalled = installedPkgIds.includes(pkg.id);
+    const status = { pkg, installed: isInstalled };
+    packageStatuses.push(status);
+    if (!isInstalled) missingPackages.push(status);
+  }
+  console.log(kleur_default.bold("\n  Pi Runtime"));
+  console.log(kleur_default.dim("  " + "-".repeat(50)));
+  console.log(kleur_default.dim(`  Extensions: ~/.pi/agent/extensions/ \u2192 .xtrm/${EXTENSION_SOURCE_DIR}/`));
+  const pkgOk = packageStatuses.filter((s) => s.installed).length;
+  console.log(kleur_default.dim(`  Packages:   ${pkgOk}/${packageStatuses.length} installed`));
+  if (missingPackages.length > 0) {
+    const names = missingPackages.map((s) => s.pkg.displayName).join(", ");
+    console.log(kleur_default.yellow(`  Missing:    ${names}`));
+  }
+  console.log(kleur_default.dim("  " + "-".repeat(50)));
+  const legacyCleanup = await cleanupLegacyProjectExtensionCopies(resolvedProjectRoot, dryRun, log);
+  result.extensionsRemoved.push(...legacyCleanup.removed);
+  result.failed.push(...legacyCleanup.failed);
+  for (const status of missingPackages) {
+    const { pkg } = status;
+    if (dryRun) {
+      log(`[DRY RUN] pi install ${pkg.id}`);
+      continue;
+    }
+    try {
+      const r = (0, import_child_process3.spawnSync)("pi", ["install", pkg.id], { stdio: "pipe", encoding: "utf8" });
+      if (r.status === 0) {
+        result.packagesInstalled.push(pkg.id);
+        log(`${sym.ok} ${pkg.displayName}`);
+      } else {
+        result.failed.push(pkg.id);
+        log(kleur_default.yellow(`\u26A0 ${pkg.displayName} \u2014 install failed`));
+      }
+    } catch (err) {
+      result.failed.push(pkg.id);
+      log(kleur_default.red(`\u2717 ${pkg.displayName}: ${err}`));
+    }
+  }
+  const alwaysGlobalInstallResult = await ensureAlwaysGlobalPiPackages(dryRun, log);
+  result.packagesInstalled.push(...alwaysGlobalInstallResult.installed);
+  result.failed.push(...alwaysGlobalInstallResult.failed);
+  const skillsRoot = resolveSkillsRoot(resolvedProjectRoot);
+  if (await import_fs_extra9.default.pathExists(import_path4.default.join(skillsRoot, "default"))) {
+    const invariantViolations = await validateSkillsInvariants(skillsRoot);
+    if (invariantViolations.length > 0) {
+      const summary = invariantViolations.map((violation) => `${violation.code}: ${violation.message}`).join("; ");
+      throw new Error(`Skills invariants failed. ${summary}`);
+    }
+    if (!dryRun) {
+      await rebuildRuntimeActiveView("pi", skillsRoot);
+    }
+  }
+  await updatePiSettings(resolvedProjectRoot, dryRun, log);
+  const requiredFailed = missingPackages.filter(
+    (s) => s.pkg.required && result.failed.includes(s.pkg.id)
+  );
+  if (missingPackages.length === 0 || result.failed.length === 0) {
+    console.log(t.success("  \u2713 All required items present.\n"));
+  } else if (requiredFailed.length === 0) {
+    console.log(t.success("  \u2713 All required items present.\n"));
+  } else {
+    console.log(kleur_default.yellow("  \u26A0 Missing required items.\n"));
+  }
+  return result;
+}
+
+// src/commands/pi-install.ts
 var PI_AGENT_DIR2 = process.env.PI_AGENT_DIR || import_path5.default.join((0, import_node_os2.homedir)(), ".pi", "agent");
 function ensurePnpm(dryRun) {
   if (isPnpmInstalled()) {
@@ -45478,6 +45694,33 @@ function createPiCommand() {
     const bundleRoot = await findRepoRoot();
     const sourceDir = import_path7.default.join(bundleRoot, ".xtrm", "extensions");
     const globalTargetDir = import_path7.default.join(PI_AGENT_DIR4, "extensions");
+    try {
+      const staleOverride = await remediateStalePiMcpAdapterOverride(false);
+      if (staleOverride.stale && staleOverride.remediated) {
+        console.log(t.success("  \u2713 removed stale ~/.pi/agent/extensions/pi-mcp-adapter override"));
+      } else if (staleOverride.stale) {
+        console.log(kleur_default.yellow("  \u26A0 stale ~/.pi/agent/extensions/pi-mcp-adapter override detected"));
+        allOk = false;
+      } else {
+        console.log(t.success("  \u2713 pi-mcp-adapter override check passed"));
+      }
+    } catch (error48) {
+      console.log(kleur_default.yellow(`  \u26A0 failed to remediate pi-mcp-adapter override: ${error48}`));
+      allOk = false;
+    }
+    try {
+      const coreStatus = await ensureCorePackageSymlink(import_path7.default.join(sourceDir, "core"), projectRoot, false);
+      if (coreStatus === "repaired" || coreStatus === "created") {
+        console.log(t.success("  \u2713 repaired .xtrm/extensions/node_modules/@xtrm/pi-core symlink"));
+      } else if (coreStatus === "ok") {
+        console.log(t.success("  \u2713 @xtrm/pi-core symlink is healthy"));
+      } else if (coreStatus === "missing-source") {
+        console.log(kleur_default.dim("  \u25CB @xtrm/pi-core source not bundled in this install"));
+      }
+    } catch (error48) {
+      console.log(kleur_default.yellow(`  \u26A0 failed to ensure @xtrm/pi-core symlink: ${error48}`));
+      allOk = false;
+    }
     if (!await import_fs_extra11.default.pathExists(sourceDir)) {
       console.log(kleur_default.dim("  \u25CB managed extensions not bundled in this install"));
     } else {
@@ -45531,6 +45774,7 @@ function createPiCommand() {
 // src/commands/init.ts
 var import_path15 = __toESM(require("path"), 1);
 var import_fs_extra21 = __toESM(require_lib(), 1);
+var import_prompts3 = __toESM(require_prompts3(), 1);
 var import_child_process5 = require("child_process");
 
 // src/core/registry-scaffold.ts
@@ -45630,13 +45874,8 @@ async function scaffoldSkillsDefaultFromPackage(params) {
     return "noop";
   }
   await import_fs_extra13.default.ensureDir(import_path8.default.dirname(targetDir));
-  try {
-    await import_fs_extra13.default.ensureSymlink(sourceDir, targetDir);
-    return "symlink";
-  } catch {
-    await import_fs_extra13.default.copy(sourceDir, targetDir);
-    return "copy";
-  }
+  await import_fs_extra13.default.copy(sourceDir, targetDir);
+  return "copy";
 }
 function buildExpectedHashes(registry2) {
   const expected = /* @__PURE__ */ new Map();
@@ -48212,19 +48451,88 @@ async function runProjectBootstrap(projectRoot, isGitRepo) {
   }
   await installServiceSkillHooks(projectRoot);
 }
-async function runProjectInit(opts = {}) {
-  const { dryRun = false, yes = false } = opts;
-  const effectiveYes = yes || process.argv.includes("--yes") || process.argv.includes("-y");
-  let projectRoot;
-  let isGitRepo = true;
+function hasInteractiveTTY2() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+async function resolveInitProjectRoot(yes) {
+  const cwd = import_path15.default.resolve(process.cwd());
+  let gitRoot;
   try {
-    projectRoot = getProjectRoot();
+    gitRoot = getProjectRoot();
   } catch {
-    projectRoot = process.cwd();
-    isGitRepo = false;
     console.log(kleur_default.yellow("\n  \u26A0 Not a git repository \u2014 git-dependent phases (beads, gitnexus) will be skipped"));
     console.log(kleur_default.dim("    Run git init first, then: gitnexus analyze\n"));
+    return { projectRoot: cwd, isGitRepo: false, aborted: false };
+  }
+  const resolvedGitRoot = import_path15.default.resolve(gitRoot);
+  if (resolvedGitRoot === cwd) {
+    return { projectRoot: resolvedGitRoot, isGitRepo: true, aborted: false };
+  }
+  console.log(kleur_default.yellow("\n  \u26A0 CWD is not the git root."));
+  console.log(kleur_default.dim(`    CWD:      ${cwd}`));
+  console.log(kleur_default.dim(`    Git root: ${resolvedGitRoot}`));
+  if (yes) {
+    console.log(kleur_default.dim("    --yes supplied; proceeding with the git root.\n"));
+    return { projectRoot: resolvedGitRoot, isGitRepo: true, aborted: false };
+  }
+  if (!hasInteractiveTTY2()) {
+    console.log(kleur_default.red("    Non-interactive session cannot choose automatically."));
+    console.log(kleur_default.dim("    Re-run with --yes to proceed with the git root, or run from the git root directory.\n"));
+    return { projectRoot: resolvedGitRoot, isGitRepo: true, aborted: true };
+  }
+  const { action } = await (0, import_prompts3.default)({
+    type: "select",
+    name: "action",
+    message: "CWD is not the git root. Run git init here first, or continue targeting the git root?",
+    choices: [
+      { title: "Abort and show instructions", value: "abort" },
+      { title: "Run git init in CWD and use this directory", value: "git-init" },
+      { title: "Proceed anyway and target the git root", value: "proceed" }
+    ],
+    initial: 0
+  });
+  if (action === "git-init") {
+    const initResult = (0, import_child_process5.spawnSync)("git", ["init"], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    if (initResult.status !== 0) {
+      if (initResult.stdout) process.stdout.write(initResult.stdout);
+      if (initResult.stderr) process.stderr.write(initResult.stderr);
+      console.log(kleur_default.red("\n  \u2717 Failed to initialize git repository in CWD."));
+      console.log(kleur_default.dim("    Fix git init errors and re-run xtrm init.\n"));
+      return { projectRoot: resolvedGitRoot, isGitRepo: true, aborted: true };
+    }
+    try {
+      const refreshedGitRoot = getProjectRoot();
+      console.log(kleur_default.green(`  \u2713 Initialized git repo in CWD: ${refreshedGitRoot}`));
+      return { projectRoot: import_path15.default.resolve(refreshedGitRoot), isGitRepo: true, aborted: false };
+    } catch {
+      console.log(kleur_default.red("\n  \u2717 git init succeeded, but git root could not be resolved."));
+      console.log(kleur_default.dim("    Re-run xtrm init from this directory.\n"));
+      return { projectRoot: cwd, isGitRepo: true, aborted: true };
+    }
   }
+  if (action === "proceed") {
+    console.log(kleur_default.dim("    Proceeding with the existing git root.\n"));
+    return { projectRoot: resolvedGitRoot, isGitRepo: true, aborted: false };
+  }
+  console.log(kleur_default.dim("\n  Init cancelled."));
+  console.log(kleur_default.dim(`  To initialize this directory as its own repo: cd ${cwd} && git init`));
+  console.log(kleur_default.dim(`  To target the existing repo root: cd ${resolvedGitRoot} && xtrm init
+`));
+  return { projectRoot: resolvedGitRoot, isGitRepo: true, aborted: true };
+}
+async function runProjectInit(opts = {}) {
+  const { dryRun = false, yes = false } = opts;
+  const effectiveYes = yes || process.argv.includes("--yes") || process.argv.includes("-y");
+  const rootResolution = await resolveInitProjectRoot(effectiveYes);
+  if (rootResolution.aborted) {
+    return;
+  }
+  const projectRoot = rootResolution.projectRoot;
+  const isGitRepo = rootResolution.isGitRepo;
   const inventory = await runPreflight(projectRoot, opts);
   renderInitPlan(inventory);
   if (dryRun) {
@@ -48397,7 +48705,7 @@ function getProjectRoot() {
 }
 
 // src/commands/status.ts
-var import_prompts3 = __toESM(require_prompts3(), 1);
+var import_prompts4 = __toESM(require_prompts3(), 1);
 
 // src/core/sync-executor.ts
 var import_path18 = __toESM(require("path"), 1);
@@ -49268,7 +49576,7 @@ function createStatusCommand() {
     console.log(kleur_default.yellow(`
   \u26A0  ${totalPending} pending change${totalPending !== 1 ? "s" : ""} across ${pending.length} environment${pending.length !== 1 ? "s" : ""}
 `));
-    const { selected } = await (0, import_prompts3.default)({
+    const { selected } = await (0, import_prompts4.default)({
       type: "multiselect",
       name: "selected",
       message: "Select environments to sync:",
@@ -50498,7 +50806,7 @@ function clearStatuslineClaim2(repoRoot) {
 }
 
 // src/commands/attach.ts
-var import_prompts4 = __toESM(require_prompts3(), 1);
+var import_prompts5 = __toESM(require_prompts3(), 1);
 var import_node_child_process8 = require("child_process");
 function createAttachCommand() {
   return new Command("attach").description("Re-attach to an existing xt worktree and resume the Claude or Pi session").argument("[name]", 'Worktree slug or branch name to attach to (e.g. "abc1" or "xt/abc1")').action(async (name) => {
@@ -50534,7 +50842,7 @@ function createAttachCommand() {
           value: slug
         };
       });
-      const { picked } = await (0, import_prompts4.default)({
+      const { picked } = await (0, import_prompts5.default)({
         type: "select",
         name: "picked",
         message: "Select worktree to attach",
@@ -50554,6 +50862,14 @@ function createAttachCommand() {
     console.log(kleur_default.dim(`  runtime: ${runtime}  (resuming session)`));
     console.log(kleur_default.dim(`  path:    ${target.path}
 `));
+    if (runtime === "pi") {
+      try {
+        await runPiLaunchPreflight(target.path, false);
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : String(error48);
+        console.log(kleur_default.dim(`  warning: pi launch preflight failed (${message})`));
+      }
+    }
     const result = (0, import_node_child_process8.spawnSync)(runtime, resumeArgs, {
       cwd: target.path,
       stdio: "inherit"
@@ -50562,7 +50878,7 @@ function createAttachCommand() {
   });
 }
 async function pickRuntime() {
-  const { runtime } = await (0, import_prompts4.default)({
+  const { runtime } = await (0, import_prompts5.default)({
     type: "select",
     name: "runtime",
     message: "No session metadata found \u2014 which runtime?",