xtrm-tools 0.6.0 → 0.7.0

package/cli/dist/index.cjs

@@ -34836,20 +34836,9 @@ function getInstalledPiPackages() {
   if (result.status !== 0) return [];
   const output = result.stdout;
   const packages = [];
-  let inUserPackages = false;
   for (const line of output.split("\n")) {
-    if (line.includes("User packages:")) {
-      inUserPackages = true;
-      continue;
-    }
-    if (line.includes("Project packages:")) {
-      inUserPackages = false;
-      continue;
-    }
-    if (inUserPackages) {
-      const match = line.match(/^\s+(npm:[\w\-/@]+)/);
-      if (match) packages.push(match[1]);
-    }
+    const match = line.match(/^\s+(npm:[\w\-/@]+)/);
+    if (match) packages.push(match[1]);
   }
   return packages.sort();
 }
@@ -35394,9 +35383,15 @@ function createPiCommand() {
       console.log("");
       return;
     }
-    const repoRoot = await findRepoRoot();
-    const sourceDir = import_path6.default.join(repoRoot, "config", "pi", "extensions");
-    const projectScopedDir = import_path6.default.join(repoRoot, ".pi", "extensions");
+    const gitResult = (0, import_node_child_process5.spawnSync)("git", ["rev-parse", "--show-toplevel"], {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    const projectRoot = gitResult.status === 0 ? (gitResult.stdout ?? "").trim() : process.cwd();
+    const bundleRoot = await findRepoRoot();
+    const sourceDir = import_path6.default.join(bundleRoot, "config", "pi", "extensions");
+    const projectScopedDir = import_path6.default.join(projectRoot, ".pi", "extensions");
     const targetDir = await import_fs_extra6.default.pathExists(projectScopedDir) ? projectScopedDir : import_path6.default.join(PI_AGENT_DIR4, "extensions");
     const scopeLabel = targetDir === projectScopedDir ? "project" : "global";
     if (!await import_fs_extra6.default.pathExists(sourceDir)) {
@@ -35458,9 +35453,15 @@ function createPiCommand() {
       console.log(kleur_default.yellow(`  \u26A0 missing config: ${missingConfig.join(", ")}`));
       allOk = false;
     }
-    const repoRoot = await findRepoRoot();
-    const sourceDir = import_path6.default.join(repoRoot, "config", "pi", "extensions");
-    const projectScopedDir = import_path6.default.join(repoRoot, ".pi", "extensions");
+    const gitResult = (0, import_node_child_process5.spawnSync)("git", ["rev-parse", "--show-toplevel"], {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    const projectRoot = gitResult.status === 0 ? (gitResult.stdout ?? "").trim() : process.cwd();
+    const bundleRoot = await findRepoRoot();
+    const sourceDir = import_path6.default.join(bundleRoot, "config", "pi", "extensions");
+    const projectScopedDir = import_path6.default.join(projectRoot, ".pi", "extensions");
     const targetDir = await import_fs_extra6.default.pathExists(projectScopedDir) ? projectScopedDir : import_path6.default.join(PI_AGENT_DIR4, "extensions");
     if (await import_fs_extra6.default.pathExists(sourceDir)) {
       const plan = await inventoryPiRuntime(sourceDir, targetDir);
@@ -35492,8 +35493,13 @@ function createPiCommand() {
     }
   });
   cmd.command("reload").description("Re-sync extensions, remove orphaned, and reinstall missing packages").action(async () => {
-    const repoRoot = await findRepoRoot();
-    await runPiInstall(false, false, repoRoot);
+    const r = (0, import_node_child_process5.spawnSync)("git", ["rev-parse", "--show-toplevel"], {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    const projectRoot = r.status === 0 ? (r.stdout ?? "").trim() : process.cwd();
+    await runPiInstall(false, false, projectRoot);
   });
   return cmd;
 }
@@ -35501,12 +35507,13 @@ function createPiCommand() {
 // src/commands/init.ts
 var import_path17 = __toESM(require("path"), 1);
 var import_fs_extra15 = __toESM(require_lib(), 1);
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 var import_prompts3 = __toESM(require_prompts3(), 1);
 
 // src/commands/install-service-skills.ts
 var import_path7 = __toESM(require("path"), 1);
 var import_fs_extra7 = __toESM(require_lib(), 1);
+var import_child_process4 = require("child_process");
 function resolvePkgRoot3() {
   const candidates = [
     import_path7.default.resolve(__dirname, "../.."),
@@ -35520,6 +35527,90 @@ function resolvePkgRoot3() {
 }
 var PKG_ROOT = resolvePkgRoot3();
 var SKILLS_SRC = import_path7.default.join(PKG_ROOT, "project-skills", "service-skills-set", ".claude");
+var MARKER_DOC = "# [jaggers] doc-reminder";
+var MARKER_STALENESS = "# [jaggers] skill-staleness";
+var MARKER_CHAIN = "# [jaggers] chain-githooks";
+async function installGitHooks(projectRoot, skillsSrc = SKILLS_SRC) {
+  const gitHooksSrc = import_path7.default.join(skillsSrc, "git-hooks");
+  const gitHooksDest = import_path7.default.join(projectRoot, ".claude", "git-hooks");
+  await import_fs_extra7.default.copy(gitHooksSrc, gitHooksDest, { overwrite: true });
+  const docScript = import_path7.default.join(projectRoot, ".claude", "git-hooks", "doc_reminder.py");
+  const stalenessScript = import_path7.default.join(projectRoot, ".claude", "git-hooks", "skill_staleness.py");
+  const preCommit = import_path7.default.join(projectRoot, ".githooks", "pre-commit");
+  const prePush = import_path7.default.join(projectRoot, ".githooks", "pre-push");
+  for (const hookPath of [preCommit, prePush]) {
+    if (!await import_fs_extra7.default.pathExists(hookPath)) {
+      await import_fs_extra7.default.mkdirp(import_path7.default.dirname(hookPath));
+      await import_fs_extra7.default.writeFile(hookPath, "#!/usr/bin/env bash\n", { mode: 493 });
+    }
+  }
+  const snippets = [
+    [
+      preCommit,
+      MARKER_DOC,
+      `
+${MARKER_DOC}
+if command -v python3 &>/dev/null && [ -f "${docScript}" ]; then
+    python3 "${docScript}" || true
+fi
+`
+    ],
+    [
+      prePush,
+      MARKER_STALENESS,
+      `
+${MARKER_STALENESS}
+if command -v python3 &>/dev/null && [ -f "${stalenessScript}" ]; then
+    python3 "${stalenessScript}" || true
+fi
+`
+    ]
+  ];
+  const hookFiles = [];
+  for (const [hookPath, marker, snippet] of snippets) {
+    const content = await import_fs_extra7.default.readFile(hookPath, "utf8");
+    const name = import_path7.default.basename(hookPath);
+    if (!content.includes(marker)) {
+      await import_fs_extra7.default.writeFile(hookPath, content + snippet);
+      hookFiles.push({ name, status: "added" });
+    } else {
+      hookFiles.push({ name, status: "already-present" });
+    }
+  }
+  const hooksPathResult = (0, import_child_process4.spawnSync)("git", ["config", "--get", "core.hooksPath"], {
+    cwd: projectRoot,
+    encoding: "utf8",
+    timeout: 5e3
+  });
+  const configuredHooksPath = hooksPathResult.status === 0 ? hooksPathResult.stdout.trim() : "";
+  const activeHooksDir = configuredHooksPath ? import_path7.default.isAbsolute(configuredHooksPath) ? configuredHooksPath : import_path7.default.join(projectRoot, configuredHooksPath) : import_path7.default.join(projectRoot, ".git", "hooks");
+  const activationTargets = /* @__PURE__ */ new Set([import_path7.default.join(projectRoot, ".git", "hooks"), activeHooksDir]);
+  for (const hooksDir of activationTargets) {
+    await import_fs_extra7.default.mkdirp(hooksDir);
+    for (const [name, sourceHook] of [["pre-commit", preCommit], ["pre-push", prePush]]) {
+      const targetHook = import_path7.default.join(hooksDir, name);
+      if (!await import_fs_extra7.default.pathExists(targetHook)) {
+        await import_fs_extra7.default.writeFile(targetHook, "#!/usr/bin/env bash\n", { mode: 493 });
+      } else {
+        await import_fs_extra7.default.chmod(targetHook, 493);
+      }
+      if (import_path7.default.resolve(targetHook) === import_path7.default.resolve(sourceHook)) {
+        continue;
+      }
+      const chainSnippet = `
+${MARKER_CHAIN}
+if [ -x "${sourceHook}" ]; then
+    "${sourceHook}" "$@"
+fi
+`;
+      const targetContent = await import_fs_extra7.default.readFile(targetHook, "utf8");
+      if (!targetContent.includes(MARKER_CHAIN)) {
+        await import_fs_extra7.default.writeFile(targetHook, targetContent + chainSnippet);
+      }
+    }
+  }
+  return { hookFiles };
+}
 
 // src/commands/install.ts
 var import_prompts2 = __toESM(require_prompts3(), 1);
@@ -37321,6 +37412,7 @@ var Listr = class {
 
 // src/commands/install.ts
 var import_os6 = __toESM(require("os"), 1);
+var import_node_child_process6 = require("child_process");
 
 // src/core/context.ts
 var import_os3 = __toESM(require("os"), 1);
@@ -39180,7 +39272,7 @@ var ConfigAdapter = class {
 };
 
 // src/utils/sync-mcp-cli.ts
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 var import_util2 = require("util");
 
 // src/utils/env-manager.ts
@@ -39192,7 +39284,7 @@ var ENV_FILE = import_path13.default.join(CONFIG_DIR, ".env");
 var ENV_EXAMPLE_FILE = import_path13.default.join(CONFIG_DIR, ".env.example");
 
 // src/utils/sync-mcp-cli.ts
-var execAsync = (0, import_util2.promisify)(import_child_process4.exec);
+var execAsync = (0, import_util2.promisify)(import_child_process5.exec);
 
 // src/core/rollback.ts
 var import_fs_extra12 = __toESM(require_lib(), 1);
@@ -39571,11 +39663,17 @@ async function runInstall(opts = {}) {
   const effectiveYes = yes || process.argv.includes("--yes") || process.argv.includes("-y");
   const syncType = backport ? "backport" : "sync";
   const actionLabel = backport ? "backport" : "install";
+  const gitResult = (0, import_node_child_process6.spawnSync)("git", ["rev-parse", "--show-toplevel"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  const projectRoot = gitResult.status === 0 ? (gitResult.stdout ?? "").trim() : process.cwd();
   const repoRoot = await findRepoRoot();
   const ctx = await getContext({
     createMissingDirs: !dryRun,
     isGlobal,
-    projectRoot: repoRoot
+    projectRoot
   });
   const { targets, syncMode } = ctx;
   if (!backport && !skipMachineBootstrap) {
@@ -39583,9 +39681,9 @@ async function runInstall(opts = {}) {
   }
   if (!backport) {
     if (!skipClaudeRuntimeSync) {
-      await runClaudeRuntimeSyncPhase({ repoRoot, dryRun, isGlobal });
+      await runClaudeRuntimeSyncPhase({ repoRoot: projectRoot, dryRun, isGlobal });
     }
-    await runPiInstall(dryRun, isGlobal, repoRoot);
+    await runPiInstall(dryRun, isGlobal, projectRoot);
   }
   const diffTasks = new Listr(
     targets.map((target) => ({
@@ -39658,7 +39756,7 @@ async function runInstall(opts = {}) {
 }
 
 // src/core/init-verification.ts
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 var import_fs_extra14 = __toESM(require_lib(), 1);
 var import_path16 = __toESM(require("path"), 1);
 function verifyMachineBootstrap() {
@@ -39671,7 +39769,7 @@ function verifyClaudeRuntime() {
     "github@claude-plugins-official",
     "ralph-loop@claude-plugins-official"
   ];
-  const result = (0, import_child_process5.spawnSync)("claude", ["plugin", "list"], { encoding: "utf8", stdio: "pipe" });
+  const result = (0, import_child_process6.spawnSync)("claude", ["plugin", "list"], { encoding: "utf8", stdio: "pipe" });
   const output = result.stdout ?? "";
   const xtrmToolsPlugin = output.includes("xtrm-tools@xtrm-tools") || output.includes("xtrm-tools");
   const officialPlugins = [];
@@ -39705,7 +39803,7 @@ async function verifyPiRuntime(projectRoot) {
 }
 function verifyProjectBootstrap(projectRoot) {
   const beadsInitialized = import_fs_extra14.default.pathExistsSync(import_path16.default.join(projectRoot, ".beads"));
-  const gnStatus = (0, import_child_process5.spawnSync)("gitnexus", ["status"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3 });
+  const gnStatus = (0, import_child_process6.spawnSync)("gitnexus", ["status"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3 });
   const gnText = `${gnStatus.stdout ?? ""}
 ${gnStatus.stderr ?? ""}`.toLowerCase();
   const gitnexusIndexed = gnStatus.status === 0 && !gnText.includes("stale") && !gnText.includes("not indexed") && !gnText.includes("missing");
@@ -39918,6 +40016,323 @@ async function injectProjectInstructionHeaders(projectRoot) {
     console.log(`${kleur_default.green("  \u2713")} updated ${target.output}`);
   }
 }
+async function getAvailableProjectSkills() {
+  if (!await import_fs_extra15.default.pathExists(PROJECT_SKILLS_DIR)) {
+    return [];
+  }
+  const entries = await import_fs_extra15.default.readdir(PROJECT_SKILLS_DIR);
+  const skills = [];
+  for (const entry of entries) {
+    const entryPath = import_path17.default.join(PROJECT_SKILLS_DIR, entry);
+    const stat = await import_fs_extra15.default.stat(entryPath);
+    if (stat.isDirectory() && await import_fs_extra15.default.pathExists(import_path17.default.join(entryPath, ".claude"))) {
+      skills.push(entry);
+    }
+  }
+  return skills.sort();
+}
+function getScriptFilename(hook) {
+  const cmd = hook.command || hook.hooks?.[0]?.command || "";
+  if (typeof cmd !== "string") return null;
+  const m = cmd.match(/\/hooks\/([A-Za-z0-9_/-]+\.(?:py|cjs|mjs|js))/);
+  if (m) return m[1];
+  const m2 = cmd.match(/([A-Za-z0-9_-]+\.(?:py|cjs|mjs|js))(?!.*[A-Za-z0-9._-]+\.(?:py|cjs|mjs|js))/);
+  return m2?.[1] ?? null;
+}
+function pruneStaleHooks(existing, canonical) {
+  const result = { ...existing };
+  const removed = [];
+  if (!result.hooks || typeof result.hooks !== "object") {
+    return { result, removed };
+  }
+  if (!canonical.hooks || typeof canonical.hooks !== "object") {
+    return { result, removed };
+  }
+  const canonicalScripts = /* @__PURE__ */ new Set();
+  const canonicalBasenames = /* @__PURE__ */ new Set();
+  for (const hooks of Object.values(canonical.hooks)) {
+    const hookList = Array.isArray(hooks) ? hooks : [hooks];
+    for (const wrapper of hookList) {
+      const innerHooks = wrapper.hooks || [wrapper];
+      for (const hook of innerHooks) {
+        const script = getScriptFilename(hook);
+        if (!script) continue;
+        canonicalScripts.add(script);
+        canonicalBasenames.add(import_path17.default.basename(script));
+      }
+    }
+  }
+  for (const [event, hooks] of Object.entries(result.hooks)) {
+    if (!Array.isArray(hooks)) continue;
+    const prunedWrappers = [];
+    for (const wrapper of hooks) {
+      const innerHooks = wrapper.hooks || [wrapper];
+      const keptInner = [];
+      for (const hook of innerHooks) {
+        const script = getScriptFilename(hook);
+        if (!script) {
+          keptInner.push(hook);
+          continue;
+        }
+        if (canonicalScripts.has(script)) {
+          keptInner.push(hook);
+          continue;
+        }
+        const sameSkillFamily = canonicalBasenames.has(import_path17.default.basename(script));
+        if (sameSkillFamily) {
+          removed.push(`${event}:${script}`);
+          continue;
+        }
+        keptInner.push(hook);
+      }
+      if (keptInner.length > 0) {
+        if (wrapper.hooks) {
+          prunedWrappers.push({ ...wrapper, hooks: keptInner });
+        } else if (keptInner.length === 1) {
+          prunedWrappers.push(keptInner[0]);
+        } else {
+          prunedWrappers.push({ ...wrapper, hooks: keptInner });
+        }
+      }
+    }
+    if (prunedWrappers.length > 0) {
+      result.hooks[event] = prunedWrappers;
+    } else {
+      delete result.hooks[event];
+    }
+  }
+  return { result, removed };
+}
+function deepMergeHooks(existing, incoming) {
+  const result = { ...existing };
+  if (!result.hooks) result.hooks = {};
+  if (!incoming.hooks) return result;
+  for (const [event, incomingHooks] of Object.entries(incoming.hooks)) {
+    if (!result.hooks[event]) {
+      result.hooks[event] = incomingHooks;
+    } else {
+      const existingEventHooks = Array.isArray(result.hooks[event]) ? result.hooks[event] : [result.hooks[event]];
+      const incomingEventHooks = Array.isArray(incomingHooks) ? incomingHooks : [incomingHooks];
+      const getCommand = (h) => h.command || h.hooks?.[0]?.command;
+      const getCommandKey = (cmd) => {
+        if (!cmd || typeof cmd !== "string") return null;
+        const m = cmd.match(/([A-Za-z0-9._-]+\.(?:py|cjs|mjs|js))(?!.*[A-Za-z0-9._-]+\.(?:py|cjs|mjs|js))/);
+        return m?.[1] ?? null;
+      };
+      const mergeMatcher2 = (existingMatcher, incomingMatcher) => {
+        const existingParts = existingMatcher.split("|").map((s) => s.trim()).filter(Boolean);
+        const incomingParts = incomingMatcher.split("|").map((s) => s.trim()).filter(Boolean);
+        const merged = [...existingParts];
+        for (const part of incomingParts) {
+          if (!merged.includes(part)) merged.push(part);
+        }
+        return merged.join("|");
+      };
+      const mergedEventHooks = [...existingEventHooks];
+      for (const incomingHook of incomingEventHooks) {
+        const incomingCmd = getCommand(incomingHook);
+        if (!incomingCmd) {
+          mergedEventHooks.push(incomingHook);
+          continue;
+        }
+        const incomingKey = getCommandKey(incomingCmd);
+        const existingIndex = mergedEventHooks.findIndex((h) => {
+          const existingCmd = getCommand(h);
+          if (existingCmd === incomingCmd) return true;
+          if (!incomingKey) return false;
+          return getCommandKey(existingCmd) === incomingKey;
+        });
+        if (existingIndex === -1) {
+          mergedEventHooks.push(incomingHook);
+          continue;
+        }
+        const existingHook = mergedEventHooks[existingIndex];
+        if (typeof existingHook.matcher === "string" && typeof incomingHook.matcher === "string") {
+          existingHook.matcher = mergeMatcher2(existingHook.matcher, incomingHook.matcher);
+        }
+      }
+      result.hooks[event] = mergedEventHooks;
+    }
+  }
+  return result;
+}
+function extractReadmeDescription(readmeContent) {
+  const lines = readmeContent.split("\n");
+  const headingIndex = lines.findIndex((line) => line.trim().startsWith("# "));
+  const searchStart = headingIndex >= 0 ? headingIndex + 1 : 0;
+  for (const rawLine of lines.slice(searchStart)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith("[![") || line.startsWith("<")) {
+      continue;
+    }
+    return line.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_`]/g, "").trim();
+  }
+  return "No description available";
+}
+async function installProjectSkill(toolName, projectRootOverride) {
+  const skillPath = import_path17.default.join(PROJECT_SKILLS_DIR, toolName);
+  if (!await import_fs_extra15.default.pathExists(skillPath)) {
+    console.error(kleur_default.red(`
+\u2717 Project skill '${toolName}' not found.
+`));
+    console.error(kleur_default.dim(`  Available project skills:
+`));
+    await listProjectSkills();
+    process.exit(1);
+  }
+  const projectRoot = projectRootOverride ?? getProjectRoot();
+  const claudeDir = import_path17.default.join(projectRoot, ".claude");
+  console.log(kleur_default.dim(`
+  Installing project skill: ${kleur_default.cyan(toolName)}`));
+  console.log(kleur_default.dim(`  Target: ${projectRoot}
+`));
+  const skillClaudeDir = import_path17.default.join(skillPath, ".claude");
+  const skillSettingsPath = import_path17.default.join(skillClaudeDir, "settings.json");
+  const skillSkillsDir = import_path17.default.join(skillClaudeDir, "skills");
+  const skillReadmePath = import_path17.default.join(skillPath, "README.md");
+  if (await import_fs_extra15.default.pathExists(skillSettingsPath)) {
+    console.log(kleur_default.bold("\u2500\u2500 Installing Hooks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const targetSettingsPath = import_path17.default.join(claudeDir, "settings.json");
+    await import_fs_extra15.default.mkdirp(import_path17.default.dirname(targetSettingsPath));
+    let existingSettings = {};
+    if (await import_fs_extra15.default.pathExists(targetSettingsPath)) {
+      try {
+        existingSettings = JSON.parse(await import_fs_extra15.default.readFile(targetSettingsPath, "utf8"));
+      } catch {
+      }
+    }
+    const incomingSettings = JSON.parse(await import_fs_extra15.default.readFile(skillSettingsPath, "utf8"));
+    const { result: prunedSettings, removed } = pruneStaleHooks(existingSettings, incomingSettings);
+    if (removed.length > 0) {
+      console.log(kleur_default.yellow(`  \u21B3 Pruned ${removed.length} stale hook(s): ${removed.join(", ")}`));
+    }
+    const mergedSettings = deepMergeHooks(prunedSettings, incomingSettings);
+    await import_fs_extra15.default.writeFile(targetSettingsPath, JSON.stringify(mergedSettings, null, 2) + "\n");
+    console.log(`${kleur_default.green("  \u2713")} settings.json (hooks merged)`);
+  }
+  if (await import_fs_extra15.default.pathExists(skillSkillsDir)) {
+    console.log(kleur_default.bold("\n\u2500\u2500 Installing Skills \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const targetSkillsDir = import_path17.default.join(claudeDir, "skills");
+    const skillEntries = await import_fs_extra15.default.readdir(skillSkillsDir);
+    for (const entry of skillEntries) {
+      const src = import_path17.default.join(skillSkillsDir, entry);
+      const dest = import_path17.default.join(targetSkillsDir, entry);
+      await import_fs_extra15.default.copy(src, dest, {
+        filter: (src2) => !src2.includes(".Zone.Identifier") && !src2.includes("__pycache__") && !src2.includes(".pytest_cache") && !src2.endsWith(".pyc")
+      });
+      console.log(`${kleur_default.green("  \u2713")} .claude/skills/${entry}/`);
+    }
+  }
+  if (await import_fs_extra15.default.pathExists(skillClaudeDir)) {
+    const claudeEntries = await import_fs_extra15.default.readdir(skillClaudeDir);
+    for (const entry of claudeEntries) {
+      if (entry === "settings.json" || entry === "skills") {
+        continue;
+      }
+      const src = import_path17.default.join(skillClaudeDir, entry);
+      const dest = import_path17.default.join(claudeDir, entry);
+      await import_fs_extra15.default.copy(src, dest, {
+        filter: (src2) => !src2.includes(".Zone.Identifier") && !src2.includes("__pycache__") && !src2.includes(".pytest_cache") && !src2.endsWith(".pyc")
+      });
+      console.log(`${kleur_default.green("  \u2713")} .claude/${entry}/`);
+    }
+  }
+  const claudeSkillsDir = import_path17.default.join(claudeDir, "skills");
+  if (await import_fs_extra15.default.pathExists(claudeSkillsDir)) {
+    const agentsDir = import_path17.default.join(projectRoot, ".agents");
+    const agentsSkillsLink = import_path17.default.join(agentsDir, "skills");
+    const symlinkTarget = import_path17.default.join("..", ".claude", "skills");
+    let needsSymlink = true;
+    if (await import_fs_extra15.default.pathExists(agentsSkillsLink)) {
+      try {
+        const stat = await import_fs_extra15.default.lstat(agentsSkillsLink);
+        if (stat.isSymbolicLink()) {
+          const current = await import_fs_extra15.default.readlink(agentsSkillsLink);
+          if (current === symlinkTarget) {
+            needsSymlink = false;
+          } else {
+            await import_fs_extra15.default.remove(agentsSkillsLink);
+          }
+        } else {
+          console.log(kleur_default.yellow("  \u26A0 .agents/skills/ is a real directory \u2014 skipping Pi symlink"));
+          needsSymlink = false;
+        }
+      } catch {
+        needsSymlink = true;
+      }
+    }
+    if (needsSymlink) {
+      await import_fs_extra15.default.mkdirp(agentsDir);
+      await import_fs_extra15.default.symlink(symlinkTarget, agentsSkillsLink);
+      console.log(`${kleur_default.green("  \u2713")} .agents/skills \u2192 ../.claude/skills`);
+    } else {
+      console.log(kleur_default.dim("  \u2713 .agents/skills symlink already in place"));
+    }
+  }
+  if (await import_fs_extra15.default.pathExists(skillReadmePath)) {
+    console.log(kleur_default.bold("\n\u2500\u2500 Installing Documentation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const docsDir = import_path17.default.join(claudeDir, "docs");
+    await import_fs_extra15.default.mkdirp(docsDir);
+    const destReadme = import_path17.default.join(docsDir, `${toolName}-readme.md`);
+    await import_fs_extra15.default.copy(skillReadmePath, destReadme);
+    console.log(`${kleur_default.green("  \u2713")} .claude/docs/${toolName}-readme.md`);
+  }
+  if (toolName === "service-skills-set") {
+    console.log(kleur_default.bold("\n\u2500\u2500 Installing Git Hooks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    await installGitHooks(projectRoot, skillClaudeDir);
+    console.log(`${kleur_default.green("  \u2713")} .githooks/pre-commit`);
+    console.log(`${kleur_default.green("  \u2713")} .githooks/pre-push`);
+    console.log(`${kleur_default.green("  \u2713")} activated in .git/hooks/`);
+  }
+  console.log(kleur_default.bold("\n\u2500\u2500 Post-Install Steps \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(kleur_default.yellow("\n  \u26A0 IMPORTANT: Manual setup required!\n"));
+  console.log(kleur_default.white(`  ${toolName} requires additional configuration.`));
+  console.log(kleur_default.white(`  Please read: ${kleur_default.cyan(".claude/docs/" + toolName + "-readme.md")}
+`));
+  if (toolName === "tdd-guard") {
+    const tddGuardCheck = (0, import_child_process7.spawnSync)("tdd-guard", ["--version"], { stdio: "pipe" });
+    if (tddGuardCheck.status !== 0) {
+      console.log(kleur_default.red("  \u2717 tdd-guard CLI not found globally!\n"));
+      console.log(kleur_default.white("  Install the global CLI:"));
+      console.log(kleur_default.cyan("    npm install -g tdd-guard\n"));
+    } else {
+      console.log(kleur_default.green("  \u2713 tdd-guard CLI found globally"));
+    }
+    console.log(kleur_default.white("\n  Install a test reporter (choose one):"));
+    console.log(kleur_default.dim("    npm install --save-dev tdd-guard-vitest    # Vitest"));
+    console.log(kleur_default.dim("    npm install --save-dev tdd-guard-jest      # Jest"));
+    console.log(kleur_default.dim("    pip install tdd-guard-pytest               # pytest\n"));
+  }
+  if (toolName === "quality-gates") {
+    console.log(kleur_default.white("  Install language dependencies:\n"));
+    console.log(kleur_default.white("  TypeScript:"));
+    console.log(kleur_default.dim("    npm install --save-dev typescript eslint prettier"));
+    console.log(kleur_default.white("\n  Python:"));
+    console.log(kleur_default.dim("    pip install ruff mypy"));
+    console.log(kleur_default.white("\n  For TDD (test-first) enforcement, install separately:"));
+    console.log(kleur_default.dim("    npm install -g tdd-guard"));
+    console.log(kleur_default.dim("    xtrm install project tdd-guard\n"));
+  }
+  console.log(kleur_default.green("  \u2713 Installation complete!\n"));
+}
+async function installAllProjectSkills(projectRootOverride) {
+  const skills = await getAvailableProjectSkills();
+  if (skills.length === 0) {
+    console.log(kleur_default.dim("  No project skills available.\n"));
+    return;
+  }
+  const projectRoot = projectRootOverride ?? getProjectRoot();
+  console.log(kleur_default.bold(`
+Installing ${skills.length} project skills:
+`));
+  for (const skill of skills) {
+    console.log(kleur_default.dim(`  \u2022 ${skill}`));
+  }
+  console.log("");
+  for (const skill of skills) {
+    await installProjectSkill(skill, projectRoot);
+  }
+}
 async function runPreflight(projectRoot, opts) {
   const repoRoot = await findRepoRoot().catch(() => projectRoot);
   const bootstrapPlan = inventoryDeps();
@@ -39926,7 +40341,8 @@ async function runPreflight(projectRoot, opts) {
     const ctx = await getContext({
       createMissingDirs: false,
       isGlobal: opts.global,
-      projectRoot: repoRoot
+      projectRoot
+      // Target project, not source repo
     });
     for (const target of ctx.targets) {
       try {
@@ -39941,7 +40357,7 @@ async function runPreflight(projectRoot, opts) {
   } catch {
   }
   const needsBdInit = !await import_fs_extra15.default.pathExists(import_path17.default.join(projectRoot, ".beads"));
-  const gitnexusStatus = (0, import_child_process6.spawnSync)("gitnexus", ["status"], {
+  const gitnexusStatus = (0, import_child_process7.spawnSync)("gitnexus", ["status"], {
     cwd: projectRoot,
     encoding: "utf8",
     timeout: 5e3
@@ -39974,7 +40390,8 @@ function renderInitPlan(inventory) {
   const projActions = [
     needsBdInit ? "bd init \u2014 initialize beads workspace" : null,
     needsGitNexus ? "gitnexus analyze \u2014 build code index" : null,
-    "AGENTS.md + CLAUDE.md \u2014 workflow headers"
+    "AGENTS.md + CLAUDE.md \u2014 workflow headers",
+    "project-skills \u2014 service-skills-set, quality-gates"
   ].filter(Boolean);
   for (const action of projActions) {
     console.log(`${kleur_default.cyan("  \u2022")}  ${action}`);
@@ -40000,6 +40417,7 @@ async function runProjectBootstrap(projectRoot) {
   await runBdInitForProject(projectRoot);
   await injectProjectInstructionHeaders(projectRoot);
   await runGitNexusInitForProject(projectRoot);
+  await installAllProjectSkills(projectRoot);
 }
 async function runProjectInit(opts = {}) {
   const { dryRun = false, yes = false } = opts;
@@ -40048,7 +40466,7 @@ async function runProjectInit(opts = {}) {
 }
 async function runBdInitForProject(projectRoot) {
   console.log(kleur_default.bold("Running beads initialization (bd init)..."));
-  const result = (0, import_child_process6.spawnSync)("bd", ["init"], {
+  const result = (0, import_child_process7.spawnSync)("bd", ["init"], {
     cwd: projectRoot,
     encoding: "utf8",
     timeout: 15e3
@@ -40073,7 +40491,7 @@ ${result.stderr || ""}`.toLowerCase();
   if (result.stderr) process.stderr.write(result.stderr);
 }
 async function runGitNexusInitForProject(projectRoot) {
-  const gitnexusCheck = (0, import_child_process6.spawnSync)("gitnexus", ["--version"], {
+  const gitnexusCheck = (0, import_child_process7.spawnSync)("gitnexus", ["--version"], {
     cwd: projectRoot,
     encoding: "utf8",
     timeout: 5e3
@@ -40084,7 +40502,7 @@ async function runGitNexusInitForProject(projectRoot) {
     return;
   }
   console.log(kleur_default.bold("Checking GitNexus index status..."));
-  const status = (0, import_child_process6.spawnSync)("gitnexus", ["status"], {
+  const status = (0, import_child_process7.spawnSync)("gitnexus", ["status"], {
     cwd: projectRoot,
     encoding: "utf8",
     timeout: 1e4
@@ -40097,7 +40515,7 @@ ${status.stderr || ""}`.toLowerCase();
     return;
   }
   console.log(kleur_default.bold("Running GitNexus indexing (gitnexus analyze)..."));
-  const analyze = (0, import_child_process6.spawnSync)("gitnexus", ["analyze"], {
+  const analyze = (0, import_child_process7.spawnSync)("gitnexus", ["analyze"], {
     cwd: projectRoot,
     encoding: "utf8",
     timeout: 12e4
@@ -40110,8 +40528,46 @@ ${status.stderr || ""}`.toLowerCase();
   if (analyze.stderr) process.stderr.write(analyze.stderr);
   console.log(kleur_default.yellow(`  \u26A0 gitnexus analyze exited with code ${analyze.status}`));
 }
+async function listProjectSkills() {
+  const entries = await getAvailableProjectSkills();
+  if (entries.length === 0) {
+    console.log(kleur_default.dim("  No project skills available.\n"));
+    return;
+  }
+  const skills = [];
+  for (const entry of entries) {
+    const readmePath = import_path17.default.join(PROJECT_SKILLS_DIR, entry, "README.md");
+    let description = "No description available";
+    if (await import_fs_extra15.default.pathExists(readmePath)) {
+      const readmeContent = await import_fs_extra15.default.readFile(readmePath, "utf8");
+      description = extractReadmeDescription(readmeContent).slice(0, 80);
+    }
+    skills.push({ name: entry, description });
+  }
+  if (skills.length === 0) {
+    console.log(kleur_default.dim("  No project skills available.\n"));
+    return;
+  }
+  console.log(kleur_default.bold("\nAvailable Project Skills:\n"));
+  const Table = require_cli_table3();
+  const table = new Table({
+    head: [kleur_default.cyan("Skill"), kleur_default.cyan("Description")],
+    colWidths: [25, 60],
+    style: { head: [], border: [] }
+  });
+  for (const skill of skills) {
+    table.push([kleur_default.white(skill.name), kleur_default.dim(skill.description)]);
+  }
+  console.log(table.toString());
+  console.log(kleur_default.bold("\n\nUsage (legacy):\n"));
+  console.log(kleur_default.dim("  xtrm install project <skill-name>   Install a legacy project skill"));
+  console.log(kleur_default.dim("  xtrm install project all            Install all legacy project skills"));
+  console.log(kleur_default.dim("  xtrm install project list           List available legacy skills\n"));
+  console.log(kleur_default.bold("Preferred:\n"));
+  console.log(kleur_default.dim("  xtrm init                           Bootstrap project data for global hooks/skills\n"));
+}
 function getProjectRoot() {
-  const result = (0, import_child_process6.spawnSync)("git", ["rev-parse", "--show-toplevel"], {
+  const result = (0, import_child_process7.spawnSync)("git", ["rev-parse", "--show-toplevel"], {
     encoding: "utf8",
     timeout: 5e3
   });
@@ -54488,17 +54944,17 @@ function createCleanCommand() {
 
 // src/commands/end.ts
 var import_prompts5 = __toESM(require_prompts3(), 1);
-var import_node_child_process6 = require("child_process");
+var import_node_child_process7 = require("child_process");
 function git(args, cwd) {
-  const r = (0, import_node_child_process6.spawnSync)("git", args, { cwd, encoding: "utf8", stdio: "pipe" });
+  const r = (0, import_node_child_process7.spawnSync)("git", args, { cwd, encoding: "utf8", stdio: "pipe" });
   return { ok: r.status === 0, out: (r.stdout ?? "").trim(), err: (r.stderr ?? "").trim() };
 }
 function bd(args, cwd) {
-  const r = (0, import_node_child_process6.spawnSync)("bd", args, { cwd, encoding: "utf8", stdio: "pipe" });
+  const r = (0, import_node_child_process7.spawnSync)("bd", args, { cwd, encoding: "utf8", stdio: "pipe" });
   return { ok: r.status === 0, out: (r.stdout ?? "").trim() };
 }
 function npm(args, cwd) {
-  const r = (0, import_node_child_process6.spawnSync)("npm", args, { cwd, encoding: "utf8", stdio: "pipe" });
+  const r = (0, import_node_child_process7.spawnSync)("npm", args, { cwd, encoding: "utf8", stdio: "pipe" });
   return { ok: r.status === 0, out: (r.stdout ?? "").trim(), err: (r.stderr ?? "").trim() };
 }
 var CONVENTIONAL_SCOPES = /* @__PURE__ */ new Set([
@@ -54757,7 +55213,7 @@ function createEndCommand() {
     console.log(kleur_default.dim("  Creating PR..."));
     const prArgs = ["pr", "create", "--title", prTitle, "--body", prBody];
     if (opts.draft) prArgs.push("--draft");
-    const prResult = (0, import_node_child_process6.spawnSync)("gh", prArgs, { cwd, encoding: "utf8", stdio: "pipe" });
+    const prResult = (0, import_node_child_process7.spawnSync)("gh", prArgs, { cwd, encoding: "utf8", stdio: "pipe" });
     if (prResult.status !== 0) {
       console.error(kleur_default.red(`
   \u2717 PR creation failed:
@@ -54788,7 +55244,7 @@ function createEndCommand() {
         try {
           const repoRoot = git(["rev-parse", "--show-toplevel"], cwd).out;
           unregisterPluginsForWorktree(cwd);
-          const removeResult = (0, import_node_child_process6.spawnSync)(
+          const removeResult = (0, import_node_child_process7.spawnSync)(
             "git",
             ["worktree", "remove", cwd, "--force"],
             { cwd: repoRoot, encoding: "utf8", stdio: "pipe" }
@@ -54812,11 +55268,11 @@ function createEndCommand() {
 
 // src/commands/worktree.ts
 var import_prompts6 = __toESM(require_prompts3(), 1);
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 var import_node_fs5 = require("fs");
 var import_node_path6 = require("path");
 function listXtWorktrees(repoRoot) {
-  const r = (0, import_node_child_process7.spawnSync)("git", ["worktree", "list", "--porcelain"], {
+  const r = (0, import_node_child_process8.spawnSync)("git", ["worktree", "list", "--porcelain"], {
     cwd: repoRoot,
     encoding: "utf8",
     stdio: "pipe"
@@ -54850,7 +55306,7 @@ function listXtWorktrees(repoRoot) {
       wt.launchedAt = meta3.launchedAt;
     } catch {
     }
-    const logR = (0, import_node_child_process7.spawnSync)("git", ["log", "-1", "--format=%ci%s", "HEAD"], {
+    const logR = (0, import_node_child_process8.spawnSync)("git", ["log", "-1", "--format=%ci%s", "HEAD"], {
       cwd: wt.path,
       encoding: "utf8",
       stdio: "pipe"
@@ -54867,7 +55323,7 @@ function listXtWorktrees(repoRoot) {
 }
 function isMergedIntoMain(branch, repoRoot) {
   const branchShort = branch.replace("refs/heads/", "");
-  const r = (0, import_node_child_process7.spawnSync)("git", ["branch", "--merged", "origin/main", "--list", branchShort], {
+  const r = (0, import_node_child_process8.spawnSync)("git", ["branch", "--merged", "origin/main", "--list", branchShort], {
     cwd: repoRoot,
     encoding: "utf8",
     stdio: "pipe"
@@ -54876,7 +55332,7 @@ function isMergedIntoMain(branch, repoRoot) {
 }
 function getPrStatus(branch, repoRoot) {
   const branchShort = branch.replace("refs/heads/", "");
-  const r = (0, import_node_child_process7.spawnSync)("gh", ["pr", "list", "--head", branchShort, "--state", "all", "--json", "state,url", "--limit", "1"], {
+  const r = (0, import_node_child_process8.spawnSync)("gh", ["pr", "list", "--head", branchShort, "--state", "all", "--json", "state,url", "--limit", "1"], {
     cwd: repoRoot,
     encoding: "utf8",
     stdio: "pipe"
@@ -54891,7 +55347,7 @@ function getPrStatus(branch, repoRoot) {
   }
 }
 function getRepoRoot(cwd) {
-  const r = (0, import_node_child_process7.spawnSync)("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: "pipe" });
+  const r = (0, import_node_child_process8.spawnSync)("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: "pipe" });
   return r.ok ? r.stdout.trim() : cwd;
 }
 function createWorktreeCommand() {
@@ -54953,7 +55409,7 @@ function createWorktreeCommand() {
       return;
     }
     for (const wt of merged) {
-      const r = (0, import_node_child_process7.spawnSync)("git", ["worktree", "remove", wt.path, "--force"], {
+      const r = (0, import_node_child_process8.spawnSync)("git", ["worktree", "remove", wt.path, "--force"], {
         cwd: repoRoot,
         encoding: "utf8",
         stdio: "pipe"
@@ -54994,7 +55450,7 @@ function createWorktreeCommand() {
       console.log(kleur_default.dim("  Cancelled\n"));
       return;
     }
-    const r = (0, import_node_child_process7.spawnSync)("git", ["worktree", "remove", target.path, "--force"], {
+    const r = (0, import_node_child_process8.spawnSync)("git", ["worktree", "remove", target.path, "--force"], {
       cwd: repoRoot,
       encoding: "utf8",
       stdio: "pipe"
@@ -55023,7 +55479,7 @@ function clearStatuslineClaim(repoRoot) {
 
 // src/commands/attach.ts
 var import_prompts7 = __toESM(require_prompts3(), 1);
-var import_node_child_process8 = require("child_process");
+var import_node_child_process9 = 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) => {
     const repoRoot = getRepoRoot(process.cwd());
@@ -55078,7 +55534,7 @@ function createAttachCommand() {
     console.log(kleur_default.dim(`  runtime: ${runtime}  (resuming session)`));
     console.log(kleur_default.dim(`  path:    ${target.path}
 `));
-    const result = (0, import_node_child_process8.spawnSync)(runtime, resumeArgs, {
+    const result = (0, import_node_child_process9.spawnSync)(runtime, resumeArgs, {
       cwd: target.path,
       stdio: "inherit"
     });
@@ -55241,16 +55697,16 @@ function isCacheValid(cache, entries, ttlMs = DEFAULT_TTL_MS) {
 }
 
 // src/commands/docs-cross-check-gh.ts
-var import_node_child_process9 = require("child_process");
+var import_node_child_process10 = require("child_process");
 function isGhAvailable() {
-  return (0, import_node_child_process9.spawnSync)("gh", ["--version"], { stdio: "pipe", encoding: "utf8" }).status === 0;
+  return (0, import_node_child_process10.spawnSync)("gh", ["--version"], { stdio: "pipe", encoding: "utf8" }).status === 0;
 }
 function fetchRecentPrs(repoRoot, days) {
   if (!isGhAvailable()) {
     console.log(kleur_default.yellow("  \u26A0 gh CLI not found \u2014 skipping PR data (install gh to enable cross-check)"));
     return [];
   }
-  const r = (0, import_node_child_process9.spawnSync)("gh", [
+  const r = (0, import_node_child_process10.spawnSync)("gh", [
     "pr",
     "list",
     "--state",
@@ -55280,11 +55736,11 @@ function fetchRecentPrs(repoRoot, days) {
 }
 
 // src/commands/docs-cross-check-bd.ts
-var import_node_child_process10 = require("child_process");
+var import_node_child_process11 = require("child_process");
 var _bdAvailable = null;
 function isBdAvailable() {
   if (_bdAvailable !== null) return _bdAvailable;
-  const r = (0, import_node_child_process10.spawnSync)("bd", ["--version"], { stdio: "pipe", encoding: "utf8" });
+  const r = (0, import_node_child_process11.spawnSync)("bd", ["--version"], { stdio: "pipe", encoding: "utf8" });
   _bdAvailable = r.status === 0;
   return _bdAvailable;
 }
@@ -55296,7 +55752,7 @@ function fetchClosedBdIssues(days) {
     logBdWarning("fetchClosedBdIssues: bd CLI not available, skipping issue fetch");
     return [];
   }
-  const r = (0, import_node_child_process10.spawnSync)("bd", [
+  const r = (0, import_node_child_process11.spawnSync)("bd", [
     "query",
     `status=closed AND updated>${days}d`,
     "--json"
@@ -55823,7 +56279,7 @@ ${content}`;
 }
 
 // src/commands/memory.ts
-var import_node_child_process11 = require("child_process");
+var import_node_child_process12 = require("child_process");
 var import_node_fs6 = require("fs");
 var import_node_path7 = require("path");
 function createMemoryCommand() {
@@ -55832,14 +56288,14 @@ function createMemoryCommand() {
 function createMemoryUpdateCommand() {
   return new Command("update").description("Run memory-processor specialist to synthesize bd memories into .xtrm/memory.md").option("--dry-run", "Report only \u2014 do not modify memories or write memory.md", false).option("--no-beads", "Skip creating a tracking bead for this run", false).action(async (opts) => {
     const cwd = process.cwd();
-    const check2 = (0, import_node_child_process11.spawnSync)("specialists", ["--version"], { encoding: "utf8", stdio: "pipe" });
+    const check2 = (0, import_node_child_process12.spawnSync)("specialists", ["--version"], { encoding: "utf8", stdio: "pipe" });
     if (check2.status !== 0) {
       console.error(kleur_default.red(
         "\n  \u2717 specialists CLI not found.\n  Install with: npm install -g @jaggerxtrm/specialists\n"
       ));
       process.exit(1);
     }
-    const list = (0, import_node_child_process11.spawnSync)("specialists", ["list", "--json"], { cwd, encoding: "utf8", stdio: "pipe" });
+    const list = (0, import_node_child_process12.spawnSync)("specialists", ["list", "--json"], { cwd, encoding: "utf8", stdio: "pipe" });
     if (list.status === 0) {
       try {
         const specialists = JSON.parse(list.stdout);
@@ -55863,7 +56319,7 @@ function createMemoryUpdateCommand() {
     console.log(kleur_default.dim(`  ${spinnerText}
 `));
     const exitCode = await new Promise((resolve2) => {
-      const proc = (0, import_node_child_process11.spawn)("specialists", args, { cwd, stdio: "inherit" });
+      const proc = (0, import_node_child_process12.spawn)("specialists", args, { cwd, stdio: "inherit" });
       proc.on("close", (code) => resolve2(code ?? 0));
     });
     if (exitCode !== 0) {
@@ -55874,39 +56330,39 @@ function createMemoryUpdateCommand() {
 }
 
 // src/commands/merge.ts
-var import_node_child_process12 = require("child_process");
+var import_node_child_process13 = require("child_process");
 var import_node_fs7 = require("fs");
 var import_node_path8 = require("path");
 function createMergeCommand() {
   return new Command("merge").description("Drain the xt worktree PR merge queue via the xt-merge specialist").option("--dry-run", "List queue and CI status without merging", false).option("--no-beads", "Skip creating a tracking bead for this run", false).action(async (opts) => {
     const cwd = process.cwd();
-    const gitCheck = (0, import_node_child_process12.spawnSync)("git", ["rev-parse", "--git-dir"], { cwd, encoding: "utf8", stdio: "pipe" });
+    const gitCheck = (0, import_node_child_process13.spawnSync)("git", ["rev-parse", "--git-dir"], { cwd, encoding: "utf8", stdio: "pipe" });
     if (gitCheck.status !== 0) {
       console.error(kleur_default.red("\n  \u2717 Not inside a git repository.\n"));
       process.exit(1);
     }
-    const ghAuth = (0, import_node_child_process12.spawnSync)("gh", ["auth", "status"], { cwd, encoding: "utf8", stdio: "pipe" });
+    const ghAuth = (0, import_node_child_process13.spawnSync)("gh", ["auth", "status"], { cwd, encoding: "utf8", stdio: "pipe" });
     if (ghAuth.status !== 0) {
       console.error(kleur_default.red(
         "\n  \u2717 gh is not authenticated.\n  Run: gh auth login\n"
       ));
       process.exit(1);
     }
-    const dirty = (0, import_node_child_process12.spawnSync)("git", ["status", "--porcelain", "--", ":!.beads/", ":!.specialists/"], { cwd, encoding: "utf8", stdio: "pipe" });
+    const dirty = (0, import_node_child_process13.spawnSync)("git", ["status", "--porcelain", "--", ":!.beads/", ":!.specialists/"], { cwd, encoding: "utf8", stdio: "pipe" });
     if (dirty.stdout.trim().length > 0) {
       console.error(kleur_default.yellow(
         '\n  \u26A0 Uncommitted changes detected.\n  The rebase cascade will check out other branches \u2014 a dirty tree\n  will either fail or carry changes onto the wrong branch.\n\n  Stash first:  git stash push -m "xt-merge cascade stash"\n  Then re-run:  xt merge\n'
       ));
       process.exit(1);
     }
-    const check2 = (0, import_node_child_process12.spawnSync)("specialists", ["--version"], { encoding: "utf8", stdio: "pipe" });
+    const check2 = (0, import_node_child_process13.spawnSync)("specialists", ["--version"], { encoding: "utf8", stdio: "pipe" });
     if (check2.status !== 0) {
       console.error(kleur_default.red(
         "\n  \u2717 specialists CLI not found.\n  Install with: npm install -g @jaggerxtrm/specialists\n"
       ));
       process.exit(1);
     }
-    const list = (0, import_node_child_process12.spawnSync)("specialists", ["list", "--json"], { cwd, encoding: "utf8", stdio: "pipe" });
+    const list = (0, import_node_child_process13.spawnSync)("specialists", ["list", "--json"], { cwd, encoding: "utf8", stdio: "pipe" });
     if (list.status === 0) {
       try {
         const specialists = JSON.parse(list.stdout);
@@ -55934,7 +56390,7 @@ function createMergeCommand() {
     } catch {
       jobsBefore = /* @__PURE__ */ new Set();
     }
-    const runProc = (0, import_node_child_process12.spawn)("specialists", args, { cwd, detached: true, stdio: "ignore" });
+    const runProc = (0, import_node_child_process13.spawn)("specialists", args, { cwd, detached: true, stdio: "ignore" });
     runProc.unref();
     const jobId = await (async () => {
       const deadline = Date.now() + 15e3;
@@ -55953,13 +56409,13 @@ function createMergeCommand() {
       console.error(kleur_default.red("\n  \u2717 Timed out waiting for xt-merge job to start.\n"));
       process.exit(1);
     }
-    (0, import_node_child_process12.spawnSync)("specialists", ["poll", jobId, "--follow"], { cwd, stdio: "inherit" });
+    (0, import_node_child_process13.spawnSync)("specialists", ["poll", jobId, "--follow"], { cwd, stdio: "inherit" });
     process.exit(0);
   });
 }
 
 // src/commands/debug.ts
-var import_node_child_process13 = require("child_process");
+var import_node_child_process14 = require("child_process");
 var import_node_fs8 = require("fs");
 var import_node_path9 = require("path");
 var KIND_LABELS = {
@@ -56107,7 +56563,7 @@ function buildWhere(opts, base) {
 }
 function queryEvents(dbPath, where, limit) {
   const sql = `SELECT id,ts,session_id,runtime,worktree,kind,tool_name,outcome,issue_id,duration_ms,data FROM events${where ? ` WHERE ${where}` : ""} ORDER BY id ASC LIMIT ${limit}`;
-  const result = (0, import_node_child_process13.spawnSync)("sqlite3", [dbPath, "-json", sql], {
+  const result = (0, import_node_child_process14.spawnSync)("sqlite3", [dbPath, "-json", sql], {
     stdio: ["pipe", "pipe", "pipe"],
     encoding: "utf8",
     timeout: 5e3