prjct-cli 1.6.10 → 1.6.11

package/dist/core/infrastructure/setup.js

@@ -49,6 +49,42 @@ var init_fs_helpers = __esm({
   }
 });
 
+// core/utils/provider-cache.ts
+async function readProviderCache() {
+  try {
+    const raw = await import_promises2.default.readFile(CACHE_FILE, "utf-8");
+    const cache = JSON.parse(raw);
+    if (!cache.timestamp || !cache.detection) return null;
+    const age = Date.now() - new Date(cache.timestamp).getTime();
+    if (age > TTL_MS) return null;
+    return cache.detection;
+  } catch {
+    return null;
+  }
+}
+async function writeProviderCache(detection) {
+  const cache = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    detection
+  };
+  await import_promises2.default.mkdir(CACHE_DIR, { recursive: true });
+  await import_promises2.default.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2));
+}
+var import_promises2, import_node_os, import_node_path2, CACHE_DIR, CACHE_FILE, TTL_MS;
+var init_provider_cache = __esm({
+  "core/utils/provider-cache.ts"() {
+    "use strict";
+    import_promises2 = __toESM(require("node:fs/promises"));
+    import_node_os = __toESM(require("node:os"));
+    import_node_path2 = __toESM(require("node:path"));
+    CACHE_DIR = import_node_path2.default.join(import_node_os.default.homedir(), ".prjct-cli", "cache");
+    CACHE_FILE = import_node_path2.default.join(CACHE_DIR, "providers.json");
+    TTL_MS = 10 * 60 * 1e3;
+    __name(readProviderCache, "readProviderCache");
+    __name(writeProviderCache, "writeProviderCache");
+  }
+});
+
 // core/infrastructure/ai-provider.ts
 var ai_provider_exports = {};
 __export(ai_provider_exports, {
@@ -77,7 +113,7 @@ __export(ai_provider_exports, {
 });
 async function whichCommand(command) {
   try {
-    const { stdout } = await execAsync(`which ${command}`);
+    const { stdout } = await execAsync(`which ${command}`, { timeout: SPAWN_TIMEOUT_MS });
     return stdout.trim();
   } catch {
     return null;
@@ -85,7 +121,7 @@ async function whichCommand(command) {
 }
 async function getCliVersion(command) {
   try {
-    const { stdout } = await execAsync(`${command} --version`);
+    const { stdout } = await execAsync(`${command} --version`, { timeout: SPAWN_TIMEOUT_MS });
     const match = stdout.match(/\d+\.\d+\.\d+/);
     return match ? match[0] : stdout.trim();
   } catch {
@@ -108,9 +144,16 @@ async function detectProvider(provider) {
     path: cliPath
   };
 }
-async function detectAllProviders() {
+async function detectAllProviders(refresh = false) {
+  if (!refresh) {
+    const cached = await readProviderCache();
+    if (cached) return cached;
+  }
   const [claude, gemini] = await Promise.all([detectProvider("claude"), detectProvider("gemini")]);
-  return { claude, gemini };
+  const detection = { claude, gemini };
+  await writeProviderCache(detection).catch(() => {
+  });
+  return detection;
 }
 async function getActiveProvider(projectProvider) {
   if (projectProvider && Providers[projectProvider]) {
@@ -147,9 +190,9 @@ function getProviderBranding(provider) {
   };
 }
 async function detectCursorProject(projectRoot) {
-  const cursorDir = import_node_path2.default.join(projectRoot, ".cursor");
-  const rulesDir = import_node_path2.default.join(cursorDir, "rules");
-  const routerPath = import_node_path2.default.join(rulesDir, "prjct.mdc");
+  const cursorDir = import_node_path3.default.join(projectRoot, ".cursor");
+  const rulesDir = import_node_path3.default.join(cursorDir, "rules");
+  const routerPath = import_node_path3.default.join(rulesDir, "prjct.mdc");
   const [detected, routerInstalled] = await Promise.all([
     fileExists(cursorDir),
     fileExists(routerPath)
@@ -165,9 +208,9 @@ async function needsCursorRouterRegeneration(projectRoot) {
   return detection.detected && !detection.routerInstalled;
 }
 async function detectWindsurfProject(projectRoot) {
-  const windsurfDir = import_node_path2.default.join(projectRoot, ".windsurf");
-  const rulesDir = import_node_path2.default.join(windsurfDir, "rules");
-  const routerPath = import_node_path2.default.join(rulesDir, "prjct.md");
+  const windsurfDir = import_node_path3.default.join(projectRoot, ".windsurf");
+  const rulesDir = import_node_path3.default.join(windsurfDir, "rules");
+  const routerPath = import_node_path3.default.join(rulesDir, "prjct.md");
   const [detected, routerInstalled] = await Promise.all([
     fileExists(windsurfDir),
     fileExists(routerPath)
@@ -187,7 +230,7 @@ async function detectAntigravity() {
   if (!configPath) {
     return { installed: false, skillInstalled: false };
   }
-  const skillPath = import_node_path2.default.join(configPath, "skills", "prjct", "SKILL.md");
+  const skillPath = import_node_path3.default.join(configPath, "skills", "prjct", "SKILL.md");
   const [installed, skillInstalled] = await Promise.all([
     fileExists(configPath),
     fileExists(skillPath)
@@ -203,14 +246,14 @@ function getGlobalContextPath(provider) {
   if (!config.configDir) {
     return null;
   }
-  return import_node_path2.default.join(config.configDir, config.contextFile);
+  return import_node_path3.default.join(config.configDir, config.contextFile);
 }
 function getGlobalSettingsPath(provider) {
   const config = Providers[provider];
   if (!config.configDir || !config.settingsFile) {
     return null;
   }
-  return import_node_path2.default.join(config.configDir, config.settingsFile);
+  return import_node_path3.default.join(config.configDir, config.settingsFile);
 }
 function getSkillsPath(provider) {
   return Providers[provider].skillsDir;
@@ -220,7 +263,7 @@ function getCommandsDir(provider) {
 }
 function getProjectCommandsPath(provider, projectRoot) {
   const config = Providers[provider];
-  return import_node_path2.default.join(projectRoot, config.commandsDir);
+  return import_node_path3.default.join(projectRoot, config.commandsDir);
 }
 async function selectProvider() {
   const detection = await detectAllProviders();
@@ -254,23 +297,25 @@ async function selectProvider() {
     detection
   };
 }
-var import_node_child_process2, import_node_os, import_node_path2, import_node_util, execAsync, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers;
+var import_node_child_process2, import_node_os2, import_node_path3, import_node_util, execAsync, SPAWN_TIMEOUT_MS, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers;
 var init_ai_provider = __esm({
   "core/infrastructure/ai-provider.ts"() {
     "use strict";
     import_node_child_process2 = require("node:child_process");
-    import_node_os = __toESM(require("node:os"));
-    import_node_path2 = __toESM(require("node:path"));
+    import_node_os2 = __toESM(require("node:os"));
+    import_node_path3 = __toESM(require("node:path"));
     import_node_util = require("node:util");
     init_fs_helpers();
+    init_provider_cache();
     execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
+    SPAWN_TIMEOUT_MS = 2e3;
     ClaudeProvider = {
       name: "claude",
       displayName: "Claude Code",
       cliCommand: "claude",
-      configDir: import_node_path2.default.join(import_node_os.default.homedir(), ".claude"),
+      configDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".claude"),
       contextFile: "CLAUDE.md",
-      skillsDir: import_node_path2.default.join(import_node_os.default.homedir(), ".claude", "skills"),
+      skillsDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".claude", "skills"),
       commandsDir: ".claude/commands",
       commandFormat: "md",
       settingsFile: "settings.json",
@@ -283,9 +328,9 @@ var init_ai_provider = __esm({
       name: "gemini",
       displayName: "Gemini CLI",
       cliCommand: "gemini",
-      configDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini"),
+      configDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini"),
       contextFile: "GEMINI.md",
-      skillsDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini", "skills"),
+      skillsDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini", "skills"),
       commandsDir: ".gemini/commands",
       commandFormat: "toml",
       settingsFile: "settings.json",
@@ -299,9 +344,9 @@ var init_ai_provider = __esm({
       displayName: "Google Antigravity",
       cliCommand: null,
       // Not a CLI command, but a platform/app
-      configDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini", "antigravity"),
+      configDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini", "antigravity"),
       contextFile: "ANTIGRAVITY.md",
-      skillsDir: import_node_path2.default.join(import_node_os.default.homedir(), ".gemini", "antigravity", "global_skills"),
+      skillsDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini", "antigravity", "global_skills"),
       commandsDir: ".agent/skills",
       // Antigravity uses .agent/skills in projects
       commandFormat: "md",
@@ -403,9 +448,9 @@ __export(setup_exports, {
 });
 module.exports = __toCommonJS(setup_exports);
 var import_node_child_process3 = require("node:child_process");
-var import_promises4 = __toESM(require("node:fs/promises"));
-var import_node_os4 = __toESM(require("node:os"));
-var import_node_path5 = __toESM(require("node:path"));
+var import_promises5 = __toESM(require("node:fs/promises"));
+var import_node_os5 = __toESM(require("node:os"));
+var import_node_path6 = __toESM(require("node:path"));
 var import_chalk = __toESM(require("chalk"));
 
 // core/constants/index.ts
@@ -788,13 +833,13 @@ var PACKAGE_ROOT = getPackageRoot();
 init_ai_provider();
 
 // core/infrastructure/command-installer.ts
-var import_promises2 = __toESM(require("node:fs/promises"));
-var import_node_os2 = __toESM(require("node:os"));
-var import_node_path3 = __toESM(require("node:path"));
+var import_promises3 = __toESM(require("node:fs/promises"));
+var import_node_os3 = __toESM(require("node:os"));
+var import_node_path4 = __toESM(require("node:path"));
 async function loadModuleConfig() {
   try {
-    const configPath = import_node_path3.default.join(getPackageRoot(), "templates/global/modules/module-config.json");
-    const content = await import_promises2.default.readFile(configPath, "utf-8");
+    const configPath = import_node_path4.default.join(getPackageRoot(), "templates/global/modules/module-config.json");
+    const content = await import_promises3.default.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -803,18 +848,18 @@ async function loadModuleConfig() {
 __name(loadModuleConfig, "loadModuleConfig");
 async function composeGlobalTemplate(profile) {
   const config = await loadModuleConfig();
-  const modulesDir = import_node_path3.default.join(getPackageRoot(), "templates/global/modules");
+  const modulesDir = import_node_path4.default.join(getPackageRoot(), "templates/global/modules");
   if (!config) {
-    const legacyPath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-    return import_promises2.default.readFile(legacyPath, "utf-8");
+    const legacyPath = import_node_path4.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
+    return import_promises3.default.readFile(legacyPath, "utf-8");
   }
   const profileName = profile || config.default;
   const selectedProfile = config.profiles[profileName];
   if (!selectedProfile) {
     const defaultProfile = config.profiles[config.default];
     if (!defaultProfile) {
-      const legacyPath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-      return import_promises2.default.readFile(legacyPath, "utf-8");
+      const legacyPath = import_node_path4.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
+      return import_promises3.default.readFile(legacyPath, "utf-8");
     }
   }
   const modules = (selectedProfile || config.profiles[config.default]).modules;
@@ -822,8 +867,8 @@ async function composeGlobalTemplate(profile) {
   parts.push("<!-- prjct:start - DO NOT REMOVE THIS MARKER -->");
   for (const moduleName of modules) {
     try {
-      const modulePath = import_node_path3.default.join(modulesDir, moduleName);
-      const content = await import_promises2.default.readFile(modulePath, "utf-8");
+      const modulePath = import_node_path4.default.join(modulesDir, moduleName);
+      const content = await import_promises3.default.readFile(modulePath, "utf-8");
       parts.push("");
       parts.push(content);
     } catch {
@@ -838,16 +883,16 @@ async function composeGlobalTemplate(profile) {
 __name(composeGlobalTemplate, "composeGlobalTemplate");
 async function installDocs() {
   try {
-    const docsDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".prjct-cli", "docs");
-    const templateDocsDir = import_node_path3.default.join(getPackageRoot(), "templates/global/docs");
-    await import_promises2.default.mkdir(docsDir, { recursive: true });
-    const docFiles = await import_promises2.default.readdir(templateDocsDir);
+    const docsDir = import_node_path4.default.join(import_node_os3.default.homedir(), ".prjct-cli", "docs");
+    const templateDocsDir = import_node_path4.default.join(getPackageRoot(), "templates/global/docs");
+    await import_promises3.default.mkdir(docsDir, { recursive: true });
+    const docFiles = await import_promises3.default.readdir(templateDocsDir);
     for (const file of docFiles) {
       if (file.endsWith(".md")) {
-        const srcPath = import_node_path3.default.join(templateDocsDir, file);
-        const destPath = import_node_path3.default.join(docsDir, file);
-        const content = await import_promises2.default.readFile(srcPath, "utf-8");
-        await import_promises2.default.writeFile(destPath, content, "utf-8");
+        const srcPath = import_node_path4.default.join(templateDocsDir, file);
+        const destPath = import_node_path4.default.join(docsDir, file);
+        const content = await import_promises3.default.readFile(srcPath, "utf-8");
+        await import_promises3.default.writeFile(destPath, content, "utf-8");
       }
     }
     return { success: true };
@@ -869,9 +914,9 @@ async function installGlobalConfig() {
     };
   }
   try {
-    await import_promises2.default.mkdir(activeProvider.configDir, { recursive: true });
-    const globalConfigPath = import_node_path3.default.join(activeProvider.configDir, activeProvider.contextFile);
-    const templatePath = import_node_path3.default.join(
+    await import_promises3.default.mkdir(activeProvider.configDir, { recursive: true });
+    const globalConfigPath = import_node_path4.default.join(activeProvider.configDir, activeProvider.contextFile);
+    const templatePath = import_node_path4.default.join(
       getPackageRoot(),
       "templates",
       "global",
@@ -879,18 +924,18 @@ async function installGlobalConfig() {
     );
     let templateContent = "";
     try {
-      templateContent = await import_promises2.default.readFile(templatePath, "utf-8");
+      templateContent = await import_promises3.default.readFile(templatePath, "utf-8");
     } catch (_error) {
       if (providerName === "claude") {
         try {
           templateContent = await composeGlobalTemplate("standard");
         } catch {
-          const fallbackTemplatePath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-          templateContent = await import_promises2.default.readFile(fallbackTemplatePath, "utf-8");
+          const fallbackTemplatePath = import_node_path4.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
+          templateContent = await import_promises3.default.readFile(fallbackTemplatePath, "utf-8");
         }
       } else {
-        const fallbackTemplatePath = import_node_path3.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
-        templateContent = await import_promises2.default.readFile(fallbackTemplatePath, "utf-8");
+        const fallbackTemplatePath = import_node_path4.default.join(getPackageRoot(), "templates/global/CLAUDE.md");
+        templateContent = await import_promises3.default.readFile(fallbackTemplatePath, "utf-8");
         if (providerName === "gemini") {
           templateContent = templateContent.replace(/Claude/g, "Gemini");
         }
@@ -899,7 +944,7 @@ async function installGlobalConfig() {
     let existingContent = "";
     let fileExists2 = false;
     try {
-      existingContent = await import_promises2.default.readFile(globalConfigPath, "utf-8");
+      existingContent = await import_promises3.default.readFile(globalConfigPath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -909,7 +954,7 @@ async function installGlobalConfig() {
       }
     }
     if (!fileExists2) {
-      await import_promises2.default.writeFile(globalConfigPath, templateContent, "utf-8");
+      await import_promises3.default.writeFile(globalConfigPath, templateContent, "utf-8");
       return {
         success: true,
         action: "created",
@@ -923,7 +968,7 @@ async function installGlobalConfig() {
         const updatedContent = `${existingContent}
 
 ${templateContent}`;
-        await import_promises2.default.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await import_promises3.default.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "appended",
@@ -939,7 +984,7 @@ ${templateContent}`;
           templateContent.indexOf(endMarker) + endMarker.length
         );
         const updatedContent = beforeMarker + prjctSection + afterMarker;
-        await import_promises2.default.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await import_promises3.default.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "updated",
@@ -966,17 +1011,17 @@ var CommandInstaller = class {
   templatesDir;
   _initialized = false;
   constructor() {
-    this.homeDir = import_node_os2.default.homedir();
-    this.templatesDir = import_node_path3.default.join(getPackageRoot(), "templates", "commands");
+    this.homeDir = import_node_os3.default.homedir();
+    this.templatesDir = import_node_path4.default.join(getPackageRoot(), "templates", "commands");
   }
   async ensureInit() {
     if (this._initialized) return;
     const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
     const activeProvider = await aiProvider.getActiveProvider();
     if (activeProvider.name === "gemini") {
-      this.claudeCommandsPath = import_node_path3.default.join(activeProvider.configDir, "commands");
+      this.claudeCommandsPath = import_node_path4.default.join(activeProvider.configDir, "commands");
     } else {
-      this.claudeCommandsPath = import_node_path3.default.join(activeProvider.configDir, "commands", "p");
+      this.claudeCommandsPath = import_node_path4.default.join(activeProvider.configDir, "commands", "p");
     }
     this.claudeConfigPath = activeProvider.configDir;
     this._initialized = true;
@@ -987,7 +1032,7 @@ var CommandInstaller = class {
   async detectActiveProvider() {
     await this.ensureInit();
     try {
-      await import_promises2.default.access(this.claudeConfigPath);
+      await import_promises3.default.access(this.claudeConfigPath);
       return true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -1007,7 +1052,7 @@ var CommandInstaller = class {
    */
   async getCommandFiles() {
     try {
-      const files = await import_promises2.default.readdir(this.templatesDir);
+      const files = await import_promises3.default.readdir(this.templatesDir);
       return files.filter((f) => f.endsWith(".md"));
     } catch (_error) {
       return [
@@ -1048,16 +1093,16 @@ var CommandInstaller = class {
     }
     try {
       await this.installRouter();
-      await import_promises2.default.mkdir(this.claudeCommandsPath, { recursive: true });
+      await import_promises3.default.mkdir(this.claudeCommandsPath, { recursive: true });
       const commandFiles = await this.getCommandFiles();
       const installed = [];
       const errors = [];
       for (const file of commandFiles) {
         try {
-          const sourcePath = import_node_path3.default.join(this.templatesDir, file);
-          const destPath = import_node_path3.default.join(this.claudeCommandsPath, file);
-          const content = await import_promises2.default.readFile(sourcePath, "utf-8");
-          await import_promises2.default.writeFile(destPath, content, "utf-8");
+          const sourcePath = import_node_path4.default.join(this.templatesDir, file);
+          const destPath = import_node_path4.default.join(this.claudeCommandsPath, file);
+          const content = await import_promises3.default.readFile(sourcePath, "utf-8");
+          await import_promises3.default.writeFile(destPath, content, "utf-8");
           installed.push(file.replace(".md", ""));
         } catch (error) {
           errors.push({ file, error: getErrorMessage(error) });
@@ -1086,8 +1131,8 @@ var CommandInstaller = class {
       const errors = [];
       for (const file of commandFiles) {
         try {
-          const filePath = import_node_path3.default.join(this.claudeCommandsPath, file);
-          await import_promises2.default.unlink(filePath);
+          const filePath = import_node_path4.default.join(this.claudeCommandsPath, file);
+          await import_promises3.default.unlink(filePath);
           uninstalled.push(file.replace(".md", ""));
         } catch (error) {
           if (error.code !== "ENOENT") {
@@ -1096,7 +1141,7 @@ var CommandInstaller = class {
         }
       }
       try {
-        await import_promises2.default.rmdir(this.claudeCommandsPath);
+        await import_promises3.default.rmdir(this.claudeCommandsPath);
       } catch (_error) {
       }
       return {
@@ -1123,8 +1168,8 @@ var CommandInstaller = class {
       };
     }
     try {
-      await import_promises2.default.access(this.claudeCommandsPath);
-      const files = await import_promises2.default.readdir(this.claudeCommandsPath);
+      await import_promises3.default.access(this.claudeCommandsPath);
+      const files = await import_promises3.default.readdir(this.claudeCommandsPath);
       const installedCommands = files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
       return {
         installed: installedCommands.length > 0,
@@ -1172,8 +1217,8 @@ var CommandInstaller = class {
    */
   async verifyTemplate(commandName) {
     try {
-      const templatePath = import_node_path3.default.join(this.templatesDir, `${commandName}.md`);
-      await import_promises2.default.access(templatePath);
+      const templatePath = import_node_path4.default.join(this.templatesDir, `${commandName}.md`);
+      await import_promises3.default.access(templatePath);
       return true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -1191,11 +1236,11 @@ var CommandInstaller = class {
     const activeProvider = await aiProvider.getActiveProvider();
     const routerFile = activeProvider.name === "gemini" ? "p.toml" : "p.md";
     try {
-      const routerSource = import_node_path3.default.join(this.templatesDir, routerFile);
-      const routerDest = import_node_path3.default.join(activeProvider.configDir, "commands", routerFile);
-      await import_promises2.default.mkdir(import_node_path3.default.dirname(routerDest), { recursive: true });
-      const content = await import_promises2.default.readFile(routerSource, "utf-8");
-      await import_promises2.default.writeFile(routerDest, content, "utf-8");
+      const routerSource = import_node_path4.default.join(this.templatesDir, routerFile);
+      const routerDest = import_node_path4.default.join(activeProvider.configDir, "commands", routerFile);
+      await import_promises3.default.mkdir(import_node_path4.default.dirname(routerDest), { recursive: true });
+      const content = await import_promises3.default.readFile(routerSource, "utf-8");
+      await import_promises3.default.writeFile(routerDest, content, "utf-8");
       return true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -1211,14 +1256,14 @@ var CommandInstaller = class {
   async removeLegacyCommands() {
     const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
     const activeProvider = await aiProvider.getActiveProvider();
-    const commandsRoot = import_node_path3.default.join(activeProvider.configDir, "commands");
+    const commandsRoot = import_node_path4.default.join(activeProvider.configDir, "commands");
     let removed = 0;
     try {
-      const files = await import_promises2.default.readdir(commandsRoot);
+      const files = await import_promises3.default.readdir(commandsRoot);
       const legacyFiles = files.filter((f) => f.startsWith("p.") && f.endsWith(".md"));
       for (const file of legacyFiles) {
         try {
-          await import_promises2.default.unlink(import_node_path3.default.join(commandsRoot, file));
+          await import_promises3.default.unlink(import_node_path4.default.join(commandsRoot, file));
           removed++;
         } catch {
         }
@@ -1243,11 +1288,11 @@ var CommandInstaller = class {
     }
     try {
       await this.installRouter();
-      await import_promises2.default.mkdir(this.claudeCommandsPath, { recursive: true });
+      await import_promises3.default.mkdir(this.claudeCommandsPath, { recursive: true });
       const templateFiles = await this.getCommandFiles();
       let installedFiles = [];
       try {
-        installedFiles = await import_promises2.default.readdir(this.claudeCommandsPath);
+        installedFiles = await import_promises3.default.readdir(this.claudeCommandsPath);
         installedFiles = installedFiles.filter((f) => f.endsWith(".md"));
       } catch (error) {
         if (isNotFoundError(error)) {
@@ -1265,11 +1310,11 @@ var CommandInstaller = class {
       };
       for (const file of templateFiles) {
         try {
-          const sourcePath = import_node_path3.default.join(this.templatesDir, file);
-          const destPath = import_node_path3.default.join(this.claudeCommandsPath, file);
+          const sourcePath = import_node_path4.default.join(this.templatesDir, file);
+          const destPath = import_node_path4.default.join(this.claudeCommandsPath, file);
           const exists = installedFiles.includes(file);
-          const content = await import_promises2.default.readFile(sourcePath, "utf-8");
-          await import_promises2.default.writeFile(destPath, content, "utf-8");
+          const content = await import_promises3.default.readFile(sourcePath, "utf-8");
+          await import_promises3.default.writeFile(destPath, content, "utf-8");
           if (!exists) {
             results.added++;
           } else {
@@ -1308,9 +1353,9 @@ var commandInstaller = new CommandInstaller();
 var command_installer_default = commandInstaller;
 
 // core/infrastructure/editors-config.ts
-var import_promises3 = __toESM(require("node:fs/promises"));
-var import_node_os3 = __toESM(require("node:os"));
-var import_node_path4 = __toESM(require("node:path"));
+var import_promises4 = __toESM(require("node:fs/promises"));
+var import_node_os4 = __toESM(require("node:os"));
+var import_node_path5 = __toESM(require("node:path"));
 var EditorsConfig = class {
   static {
     __name(this, "EditorsConfig");
@@ -1319,16 +1364,16 @@ var EditorsConfig = class {
   configDir;
   configFile;
   constructor() {
-    this.homeDir = import_node_os3.default.homedir();
-    this.configDir = import_node_path4.default.join(this.homeDir, ".prjct-cli", "config");
-    this.configFile = import_node_path4.default.join(this.configDir, "installed-editors.json");
+    this.homeDir = import_node_os4.default.homedir();
+    this.configDir = import_node_path5.default.join(this.homeDir, ".prjct-cli", "config");
+    this.configFile = import_node_path5.default.join(this.configDir, "installed-editors.json");
   }
   /**
    * Ensure config directory exists
    */
   async ensureConfigDir() {
     try {
-      await import_promises3.default.mkdir(this.configDir, { recursive: true });
+      await import_promises4.default.mkdir(this.configDir, { recursive: true });
     } catch (error) {
       console.error("[editors-config] Error creating config directory:", getErrorMessage(error));
     }
@@ -1338,7 +1383,7 @@ var EditorsConfig = class {
    */
   async loadConfig() {
     try {
-      const content = await import_promises3.default.readFile(this.configFile, "utf-8");
+      const content = await import_promises4.default.readFile(this.configFile, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -1362,7 +1407,7 @@ var EditorsConfig = class {
         lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
         path: installPath
       };
-      await import_promises3.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+      await import_promises4.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
       return true;
     } catch (error) {
       console.error("[editors-config] Error saving config:", getErrorMessage(error));
@@ -1402,7 +1447,7 @@ var EditorsConfig = class {
       }
       config.version = version;
       config.lastInstall = (/* @__PURE__ */ new Date()).toISOString();
-      await import_promises3.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+      await import_promises4.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
       return true;
     } catch (error) {
       console.error("[editors-config] Error updating version:", getErrorMessage(error));
@@ -1414,7 +1459,7 @@ var EditorsConfig = class {
    */
   async configExists() {
     try {
-      await import_promises3.default.access(this.configFile);
+      await import_promises4.default.access(this.configFile);
       return true;
     } catch (_error) {
       return false;
@@ -1428,7 +1473,7 @@ var EditorsConfig = class {
     try {
       const exists = await this.configExists();
       if (exists) {
-        await import_promises3.default.unlink(this.configFile);
+        await import_promises4.default.unlink(this.configFile);
       }
       return true;
     } catch (error) {
@@ -1580,12 +1625,12 @@ async function run() {
 __name(run, "run");
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini", "commands");
-    const routerSource = import_node_path5.default.join(getPackageRoot(), "templates", "commands", "p.toml");
-    const routerDest = import_node_path5.default.join(geminiCommandsDir, "p.toml");
-    await import_promises4.default.mkdir(geminiCommandsDir, { recursive: true });
+    const geminiCommandsDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".gemini", "commands");
+    const routerSource = import_node_path6.default.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = import_node_path6.default.join(geminiCommandsDir, "p.toml");
+    await import_promises5.default.mkdir(geminiCommandsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await import_promises4.default.copyFile(routerSource, routerDest);
+      await import_promises5.default.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -1597,15 +1642,15 @@ async function installGeminiRouter() {
 __name(installGeminiRouter, "installGeminiRouter");
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini");
-    const globalConfigPath = import_node_path5.default.join(geminiDir, "GEMINI.md");
-    const templatePath = import_node_path5.default.join(getPackageRoot(), "templates", "global", "GEMINI.md");
-    await import_promises4.default.mkdir(geminiDir, { recursive: true });
-    const templateContent = await import_promises4.default.readFile(templatePath, "utf-8");
+    const geminiDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".gemini");
+    const globalConfigPath = import_node_path6.default.join(geminiDir, "GEMINI.md");
+    const templatePath = import_node_path6.default.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    await import_promises5.default.mkdir(geminiDir, { recursive: true });
+    const templateContent = await import_promises5.default.readFile(templatePath, "utf-8");
     let existingContent = "";
     let configExists = false;
     try {
-      existingContent = await import_promises4.default.readFile(globalConfigPath, "utf-8");
+      existingContent = await import_promises5.default.readFile(globalConfigPath, "utf-8");
       configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -1615,7 +1660,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!configExists) {
-      await import_promises4.default.writeFile(globalConfigPath, templateContent, "utf-8");
+      await import_promises5.default.writeFile(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -1625,7 +1670,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      await import_promises4.default.writeFile(globalConfigPath, updatedContent2, "utf-8");
+      await import_promises5.default.writeFile(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -1637,7 +1682,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    await import_promises4.default.writeFile(globalConfigPath, updatedContent, "utf-8");
+    await import_promises5.default.writeFile(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     logger_default.warn(`Gemini config warning: ${getErrorMessage(error)}`);
@@ -1647,18 +1692,18 @@ ${templateContent}`;
 __name(installGeminiGlobalConfig, "installGeminiGlobalConfig");
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = import_node_path5.default.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = import_node_path5.default.join(prjctSkillDir, "SKILL.md");
-    const templatePath = import_node_path5.default.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
-    await import_promises4.default.mkdir(prjctSkillDir, { recursive: true });
+    const antigravitySkillsDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = import_node_path6.default.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = import_node_path6.default.join(prjctSkillDir, "SKILL.md");
+    const templatePath = import_node_path6.default.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    await import_promises5.default.mkdir(prjctSkillDir, { recursive: true });
     const skillExists = await fileExists(skillMdPath);
     if (!await fileExists(templatePath)) {
       logger_default.warn("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = await import_promises4.default.readFile(templatePath, "utf-8");
-    await import_promises4.default.writeFile(skillMdPath, templateContent, "utf-8");
+    const templateContent = await import_promises5.default.readFile(templatePath, "utf-8");
+    await import_promises5.default.writeFile(skillMdPath, templateContent, "utf-8");
     return { success: true, action: skillExists ? "updated" : "created" };
   } catch (error) {
     logger_default.warn(`Antigravity skill warning: ${getErrorMessage(error)}`);
@@ -1679,24 +1724,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = import_node_path5.default.join(projectRoot, ".cursor");
-    const rulesDir = import_node_path5.default.join(cursorDir, "rules");
-    const commandsDir = import_node_path5.default.join(cursorDir, "commands");
-    const routerMdcDest = import_node_path5.default.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = import_node_path5.default.join(getPackageRoot(), "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = import_node_path5.default.join(getPackageRoot(), "templates", "cursor", "commands");
-    await import_promises4.default.mkdir(rulesDir, { recursive: true });
-    await import_promises4.default.mkdir(commandsDir, { recursive: true });
+    const cursorDir = import_node_path6.default.join(projectRoot, ".cursor");
+    const rulesDir = import_node_path6.default.join(cursorDir, "rules");
+    const commandsDir = import_node_path6.default.join(cursorDir, "commands");
+    const routerMdcDest = import_node_path6.default.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = import_node_path6.default.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = import_node_path6.default.join(getPackageRoot(), "templates", "cursor", "commands");
+    await import_promises5.default.mkdir(rulesDir, { recursive: true });
+    await import_promises5.default.mkdir(commandsDir, { recursive: true });
     if (await fileExists(routerMdcSource)) {
-      await import_promises4.default.copyFile(routerMdcSource, routerMdcDest);
+      await import_promises5.default.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
     if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await import_promises4.default.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
+      const commandFiles = (await import_promises5.default.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = import_node_path5.default.join(cursorCommandsSource, file);
-        const dest = import_node_path5.default.join(commandsDir, file);
-        await import_promises4.default.copyFile(src, dest);
+        const src = import_node_path6.default.join(cursorCommandsSource, file);
+        const dest = import_node_path6.default.join(commandsDir, file);
+        await import_promises5.default.copyFile(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -1711,7 +1756,7 @@ async function installCursorProject(projectRoot) {
 __name(installCursorProject, "installCursorProject");
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = import_node_path5.default.join(projectRoot, ".gitignore");
+    const gitignorePath = import_node_path6.default.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -1726,7 +1771,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await import_promises4.default.readFile(gitignorePath, "utf-8");
+      content = await import_promises5.default.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -1741,7 +1786,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await import_promises4.default.writeFile(gitignorePath, newContent, "utf-8");
+    await import_promises5.default.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage(error)}`);
@@ -1750,12 +1795,12 @@ ${entriesToAdd.join("\n")}
 }
 __name(addCursorToGitignore, "addCursorToGitignore");
 async function hasCursorProject(projectRoot) {
-  return await fileExists(import_node_path5.default.join(projectRoot, ".cursor"));
+  return await fileExists(import_node_path6.default.join(projectRoot, ".cursor"));
 }
 __name(hasCursorProject, "hasCursorProject");
 async function needsCursorRegeneration(projectRoot) {
-  const cursorDir = import_node_path5.default.join(projectRoot, ".cursor");
-  const routerPath = import_node_path5.default.join(cursorDir, "rules", "prjct.mdc");
+  const cursorDir = import_node_path6.default.join(projectRoot, ".cursor");
+  const routerPath = import_node_path6.default.join(cursorDir, "rules", "prjct.mdc");
   return await fileExists(cursorDir) && !await fileExists(routerPath);
 }
 __name(needsCursorRegeneration, "needsCursorRegeneration");
@@ -1767,31 +1812,31 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = import_node_path5.default.join(projectRoot, ".windsurf");
-    const rulesDir = import_node_path5.default.join(windsurfDir, "rules");
-    const workflowsDir = import_node_path5.default.join(windsurfDir, "workflows");
-    const routerDest = import_node_path5.default.join(rulesDir, "prjct.md");
-    const routerSource = import_node_path5.default.join(getPackageRoot(), "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = import_node_path5.default.join(
+    const windsurfDir = import_node_path6.default.join(projectRoot, ".windsurf");
+    const rulesDir = import_node_path6.default.join(windsurfDir, "rules");
+    const workflowsDir = import_node_path6.default.join(windsurfDir, "workflows");
+    const routerDest = import_node_path6.default.join(rulesDir, "prjct.md");
+    const routerSource = import_node_path6.default.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = import_node_path6.default.join(
       getPackageRoot(),
       "templates",
       "windsurf",
       "workflows"
     );
-    await import_promises4.default.mkdir(rulesDir, { recursive: true });
-    await import_promises4.default.mkdir(workflowsDir, { recursive: true });
+    await import_promises5.default.mkdir(rulesDir, { recursive: true });
+    await import_promises5.default.mkdir(workflowsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await import_promises4.default.copyFile(routerSource, routerDest);
+      await import_promises5.default.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
     if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await import_promises4.default.readdir(windsurfWorkflowsSource)).filter(
+      const workflowFiles = (await import_promises5.default.readdir(windsurfWorkflowsSource)).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of workflowFiles) {
-        const src = import_node_path5.default.join(windsurfWorkflowsSource, file);
-        const dest = import_node_path5.default.join(workflowsDir, file);
-        await import_promises4.default.copyFile(src, dest);
+        const src = import_node_path6.default.join(windsurfWorkflowsSource, file);
+        const dest = import_node_path6.default.join(workflowsDir, file);
+        await import_promises5.default.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -1806,7 +1851,7 @@ async function installWindsurfProject(projectRoot) {
 __name(installWindsurfProject, "installWindsurfProject");
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = import_node_path5.default.join(projectRoot, ".gitignore");
+    const gitignorePath = import_node_path6.default.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -1821,7 +1866,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await import_promises4.default.readFile(gitignorePath, "utf-8");
+      content = await import_promises5.default.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -1836,7 +1881,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await import_promises4.default.writeFile(gitignorePath, newContent, "utf-8");
+    await import_promises5.default.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage(error)}`);
@@ -1845,34 +1890,34 @@ ${entriesToAdd.join("\n")}
 }
 __name(addWindsurfToGitignore, "addWindsurfToGitignore");
 async function hasWindsurfProject(projectRoot) {
-  return await fileExists(import_node_path5.default.join(projectRoot, ".windsurf"));
+  return await fileExists(import_node_path6.default.join(projectRoot, ".windsurf"));
 }
 __name(hasWindsurfProject, "hasWindsurfProject");
 async function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = import_node_path5.default.join(projectRoot, ".windsurf");
-  const routerPath = import_node_path5.default.join(windsurfDir, "rules", "prjct.md");
+  const windsurfDir = import_node_path6.default.join(projectRoot, ".windsurf");
+  const routerPath = import_node_path6.default.join(windsurfDir, "rules", "prjct.md");
   return await fileExists(windsurfDir) && !await fileExists(routerPath);
 }
 __name(needsWindsurfRegeneration, "needsWindsurfRegeneration");
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".prjct-cli", "projects");
+    const projectsDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".prjct-cli", "projects");
     if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = (await import_promises4.default.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await import_promises5.default.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = import_node_path5.default.join(projectsDir, projectId, "project.json");
+      const projectJsonPath = import_node_path6.default.join(projectsDir, projectId, "project.json");
       if (!await fileExists(projectJsonPath)) {
         continue;
       }
       try {
-        const content = await import_promises4.default.readFile(projectJsonPath, "utf8");
+        const content = await import_promises5.default.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          await import_promises4.default.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await import_promises5.default.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -1895,7 +1940,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
   if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(await import_promises4.default.readFile(settingsPath, "utf8"));
+      settings = JSON.parse(await import_promises5.default.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -1903,43 +1948,43 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  await import_promises4.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await import_promises5.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 __name(ensureStatusLineSettings, "ensureStatusLineSettings");
 async function installStatusLine() {
   try {
-    const claudeDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".claude");
-    const settingsPath = import_node_path5.default.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = import_node_path5.default.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = import_node_path5.default.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = import_node_path5.default.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = import_node_path5.default.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = import_node_path5.default.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = import_node_path5.default.join(prjctStatusLineDir, "config.json");
-    const assetsDir = import_node_path5.default.join(getPackageRoot(), "assets", "statusline");
-    const sourceScript = import_node_path5.default.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = import_node_path5.default.join(assetsDir, "themes");
-    const sourceLibDir = import_node_path5.default.join(assetsDir, "lib");
-    const sourceComponentsDir = import_node_path5.default.join(assetsDir, "components");
-    const sourceConfigPath = import_node_path5.default.join(assetsDir, "default-config.json");
+    const claudeDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".claude");
+    const settingsPath = import_node_path6.default.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = import_node_path6.default.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = import_node_path6.default.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = import_node_path6.default.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = import_node_path6.default.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = import_node_path6.default.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = import_node_path6.default.join(prjctStatusLineDir, "config.json");
+    const assetsDir = import_node_path6.default.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = import_node_path6.default.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = import_node_path6.default.join(assetsDir, "themes");
+    const sourceLibDir = import_node_path6.default.join(assetsDir, "lib");
+    const sourceComponentsDir = import_node_path6.default.join(assetsDir, "components");
+    const sourceConfigPath = import_node_path6.default.join(assetsDir, "default-config.json");
     if (!await fileExists(claudeDir)) {
-      await import_promises4.default.mkdir(claudeDir, { recursive: true });
+      await import_promises5.default.mkdir(claudeDir, { recursive: true });
     }
     if (!await fileExists(prjctStatusLineDir)) {
-      await import_promises4.default.mkdir(prjctStatusLineDir, { recursive: true });
+      await import_promises5.default.mkdir(prjctStatusLineDir, { recursive: true });
     }
     if (!await fileExists(prjctThemesDir)) {
-      await import_promises4.default.mkdir(prjctThemesDir, { recursive: true });
+      await import_promises5.default.mkdir(prjctThemesDir, { recursive: true });
     }
     if (!await fileExists(prjctLibDir)) {
-      await import_promises4.default.mkdir(prjctLibDir, { recursive: true });
+      await import_promises5.default.mkdir(prjctLibDir, { recursive: true });
     }
     if (!await fileExists(prjctComponentsDir)) {
-      await import_promises4.default.mkdir(prjctComponentsDir, { recursive: true });
+      await import_promises5.default.mkdir(prjctComponentsDir, { recursive: true });
     }
     if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await import_promises4.default.readFile(prjctStatusLinePath, "utf8");
+      const existingContent = await import_promises5.default.readFile(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -1947,7 +1992,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          await import_promises4.default.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await import_promises5.default.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         await installStatusLineModules(sourceLibDir, prjctLibDir);
         await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -1957,21 +2002,21 @@ async function installStatusLine() {
       }
     }
     if (await fileExists(sourceScript)) {
-      let scriptContent = await import_promises4.default.readFile(sourceScript, "utf8");
+      let scriptContent = await import_promises5.default.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await import_promises4.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await import_promises5.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
       await installStatusLineModules(sourceLibDir, prjctLibDir);
       await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
       if (await fileExists(sourceThemeDir)) {
-        const themes = await import_promises4.default.readdir(sourceThemeDir);
+        const themes = await import_promises5.default.readdir(sourceThemeDir);
         for (const theme of themes) {
-          const src = import_node_path5.default.join(sourceThemeDir, theme);
-          const dest = import_node_path5.default.join(prjctThemesDir, theme);
-          await import_promises4.default.copyFile(src, dest);
+          const src = import_node_path6.default.join(sourceThemeDir, theme);
+          const dest = import_node_path6.default.join(prjctThemesDir, theme);
+          await import_promises5.default.copyFile(src, dest);
         }
       }
       if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await import_promises4.default.copyFile(sourceConfigPath, prjctConfigPath);
+        await import_promises5.default.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -2006,7 +2051,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      await import_promises4.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await import_promises5.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -2019,10 +2064,10 @@ echo "prjct"
 __name(installStatusLine, "installStatusLine");
 async function installContext7MCP() {
   try {
-    const claudeDir = import_node_path5.default.join(import_node_os4.default.homedir(), ".claude");
-    const mcpConfigPath = import_node_path5.default.join(claudeDir, "mcp.json");
+    const claudeDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".claude");
+    const mcpConfigPath = import_node_path6.default.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
-      await import_promises4.default.mkdir(claudeDir, { recursive: true });
+      await import_promises5.default.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -2033,16 +2078,16 @@ async function installContext7MCP() {
       }
     };
     if (await fileExists(mcpConfigPath)) {
-      const existingContent = await import_promises4.default.readFile(mcpConfigPath, "utf-8");
+      const existingContent = await import_promises5.default.readFile(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      await import_promises4.default.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await import_promises5.default.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      await import_promises4.default.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      await import_promises5.default.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     logger_default.warn(`Context7 MCP setup warning: ${getErrorMessage(error)}`);
@@ -2053,13 +2098,13 @@ async function installStatusLineModules(sourceDir, destDir) {
   if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = await import_promises4.default.readdir(sourceDir);
+  const files = await import_promises5.default.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = import_node_path5.default.join(sourceDir, file);
-      const dest = import_node_path5.default.join(destDir, file);
-      await import_promises4.default.copyFile(src, dest);
-      await import_promises4.default.chmod(dest, 493);
+      const src = import_node_path6.default.join(sourceDir, file);
+      const dest = import_node_path6.default.join(destDir, file);
+      await import_promises5.default.copyFile(src, dest);
+      await import_promises5.default.chmod(dest, 493);
     }
   }
 }
@@ -2067,21 +2112,21 @@ __name(installStatusLineModules, "installStatusLineModules");
 async function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
     if (await fileExists(linkPath)) {
-      const stats = await import_promises4.default.lstat(linkPath);
+      const stats = await import_promises5.default.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = await import_promises4.default.readlink(linkPath);
+        const existingTarget = await import_promises5.default.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      await import_promises4.default.unlink(linkPath);
+      await import_promises5.default.unlink(linkPath);
     }
-    await import_promises4.default.symlink(targetPath, linkPath);
+    await import_promises5.default.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
       if (await fileExists(targetPath)) {
-        await import_promises4.default.copyFile(targetPath, linkPath);
-        await import_promises4.default.chmod(linkPath, 493);
+        await import_promises5.default.copyFile(targetPath, linkPath);
+        await import_promises5.default.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {