prjct-cli 0.60.1 → 0.61.0

package/dist/bin/prjct.mjs

@@ -16,10 +16,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __glob = (map) => (path58) => {
-  var fn = map[path58];
+var __glob = (map) => (path59) => {
+  var fn = map[path59];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path58);
+  throw new Error("Module not found in bundle: " + path59);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -4019,8 +4019,8 @@ function tryResolve(basePath, projectPath) {
   for (const ext of extensions) {
     const fullPath = basePath + ext;
     try {
-      const fs49 = __require("node:fs");
-      if (fs49.existsSync(fullPath) && fs49.statSync(fullPath).isFile()) {
+      const fs50 = __require("node:fs");
+      if (fs50.existsSync(fullPath) && fs50.statSync(fullPath).isFile()) {
         return path12.relative(projectPath, fullPath);
       }
     } catch {
@@ -5203,11 +5203,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs49 = await import("node:fs/promises");
-  const path58 = await import("node:path");
-  const fullPath = path58.isAbsolute(filePath) ? filePath : path58.join(projectPath, filePath);
+  const fs50 = await import("node:fs/promises");
+  const path59 = await import("node:path");
+  const fullPath = path59.isAbsolute(filePath) ? filePath : path59.join(projectPath, filePath);
   try {
-    const stat = await fs49.stat(fullPath);
+    const stat = await fs50.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5274,11 +5274,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs49 = await import("node:fs/promises");
-  const path58 = await import("node:path");
-  const fullPath = path58.isAbsolute(targetPath) ? targetPath : path58.join(projectPath, targetPath);
+  const fs50 = await import("node:fs/promises");
+  const path59 = await import("node:path");
+  const fullPath = path59.isAbsolute(targetPath) ? targetPath : path59.join(projectPath, targetPath);
   try {
-    const stat = await fs49.stat(fullPath);
+    const stat = await fs50.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -11788,31 +11788,33 @@ var init_orchestrator_executor = __esm({
        *
        * Reads agent markdown files from {globalPath}/agents/
        * and extracts their content and skills from frontmatter.
+       *
+       * Uses parallel file reads for performance (PRJ-110).
        */
       async loadAgents(domains, projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
         const agentsDir = path23.join(globalPath, "agents");
-        const agents = [];
-        for (const domain of domains) {
+        const agentPromises = domains.map(async (domain) => {
           const possibleNames = [`${domain}.md`, `${domain}-agent.md`, `prjct-${domain}.md`];
           for (const fileName of possibleNames) {
             const filePath = path23.join(agentsDir, fileName);
             try {
               const content = await fs24.readFile(filePath, "utf-8");
               const { frontmatter, body } = this.parseAgentFile(content);
-              agents.push({
+              return {
                 name: fileName.replace(".md", ""),
                 domain,
                 content: body,
                 skills: frontmatter.skills || [],
                 filePath
-              });
-              break;
+              };
             } catch {
             }
           }
-        }
-        return agents;
+          return null;
+        });
+        const results = await Promise.all(agentPromises);
+        return results.filter((agent) => agent !== null);
       }
       /**
        * Parse agent markdown file to extract frontmatter and body
@@ -11832,40 +11834,36 @@ var init_orchestrator_executor = __esm({
        * Load skills from agent frontmatter
        *
        * Skills are stored in ~/.claude/skills/{name}.md
+       *
+       * Uses parallel file reads for performance (PRJ-110).
        */
       async loadSkills(agents) {
         const skillsDir = path23.join(os8.homedir(), ".claude", "skills");
-        const skills = [];
-        const loadedSkillNames = /* @__PURE__ */ new Set();
+        const uniqueSkillNames = /* @__PURE__ */ new Set();
         for (const agent of agents) {
           for (const skillName of agent.skills) {
-            if (loadedSkillNames.has(skillName)) continue;
+            uniqueSkillNames.add(skillName);
+          }
+        }
+        const skillPromises = Array.from(uniqueSkillNames).map(
+          async (skillName) => {
             const flatPath = path23.join(skillsDir, `${skillName}.md`);
             const subdirPath = path23.join(skillsDir, skillName, "SKILL.md");
-            let content = null;
-            let resolvedPath = flatPath;
             try {
-              content = await fs24.readFile(subdirPath, "utf-8");
-              resolvedPath = subdirPath;
+              const content = await fs24.readFile(subdirPath, "utf-8");
+              return { name: skillName, content, filePath: subdirPath };
             } catch {
               try {
-                content = await fs24.readFile(flatPath, "utf-8");
-                resolvedPath = flatPath;
+                const content = await fs24.readFile(flatPath, "utf-8");
+                return { name: skillName, content, filePath: flatPath };
               } catch {
-                console.warn(`Skill not found: ${skillName}`);
+                return null;
               }
             }
-            if (content) {
-              skills.push({
-                name: skillName,
-                content,
-                filePath: resolvedPath
-              });
-              loadedSkillNames.add(skillName);
-            }
           }
-        }
-        return skills;
+        );
+        const results = await Promise.all(skillPromises);
+        return results.filter((skill) => skill !== null);
       }
       /**
        * Determine if task should be fragmented into subtasks
@@ -16760,16 +16758,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs49 = await import("node:fs/promises");
-        const path58 = await import("node:path");
+        const fs50 = await import("node:fs/promises");
+        const path59 = await import("node:path");
         try {
-          const files = await fs49.readdir(this.projectPath);
+          const files = await fs50.readdir(this.projectPath);
           if (files.includes("turbo.json") || files.includes("lerna.json") || files.includes("nx.json")) {
             return "monorepo";
           }
           if (files.includes("package.json")) {
-            const pkgPath = path58.join(this.projectPath, "package.json");
-            const pkgContent = await fs49.readFile(pkgPath, "utf-8");
+            const pkgPath = path59.join(this.projectPath, "package.json");
+            const pkgContent = await fs50.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -16805,32 +16803,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs49 = await import("node:fs/promises");
-        const path58 = await import("node:path");
+        const fs50 = await import("node:fs/promises");
+        const path59 = await import("node:path");
         const os17 = await import("node:os");
         const agents = [];
         try {
-          await fs49.access(path58.join(os17.homedir(), ".claude"));
+          await fs50.access(path59.join(os17.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs49.access(path58.join(this.projectPath, ".cursorrules"));
+          await fs50.access(path59.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs49.access(path58.join(this.projectPath, ".windsurfrules"));
+          await fs50.access(path59.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs49.access(path58.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs50.access(path59.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs49.access(path58.join(os17.homedir(), ".gemini"));
+          await fs50.access(path59.join(os17.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -16840,17 +16838,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs49 = await import("node:fs/promises");
-        const path58 = await import("node:path");
+        const fs50 = await import("node:fs/promises");
+        const path59 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs49.readdir(this.projectPath);
+          const files = await fs50.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path58.join(this.projectPath, "package.json");
-            const pkgContent = await fs49.readFile(pkgPath, "utf-8");
+            const pkgPath = path59.join(this.projectPath, "package.json");
+            const pkgContent = await fs50.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -18946,8 +18944,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path37.join(globalPath2, "planning", "specs");
             try {
-              const fs49 = await import("node:fs/promises");
-              const files = await fs49.readdir(specsPath2);
+              const fs50 = await import("node:fs/promises");
+              const files = await fs50.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -20090,9 +20088,125 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
   }
 });
 
-// core/services/stack-detector.ts
+// core/services/local-state-generator.ts
 import fs40 from "node:fs/promises";
 import path42 from "node:path";
+var LOCAL_STATE_FILENAME, LocalStateGenerator, localStateGenerator;
+var init_local_state_generator = __esm({
+  "core/services/local-state-generator.ts"() {
+    "use strict";
+    init_fs();
+    LOCAL_STATE_FILENAME = ".prjct-state.md";
+    LocalStateGenerator = class {
+      static {
+        __name(this, "LocalStateGenerator");
+      }
+      /**
+       * Generate .prjct-state.md in the project root
+       */
+      async generate(projectPath, state) {
+        const filePath = path42.join(projectPath, LOCAL_STATE_FILENAME);
+        const content = this.toMarkdown(state);
+        await fs40.writeFile(filePath, content, "utf-8");
+      }
+      /**
+       * Remove local state file
+       */
+      async remove(projectPath) {
+        const filePath = path42.join(projectPath, LOCAL_STATE_FILENAME);
+        try {
+          await fs40.unlink(filePath);
+        } catch (error) {
+          if (!isNotFoundError(error)) throw error;
+        }
+      }
+      /**
+       * Check if local state file exists
+       */
+      async exists(projectPath) {
+        const filePath = path42.join(projectPath, LOCAL_STATE_FILENAME);
+        try {
+          await fs40.access(filePath);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Convert state to markdown format
+       * Note: Uses runtime types since state.json has fields not in strict Zod schema
+       */
+      toMarkdown(state) {
+        const lines = [
+          "<!-- Auto-generated by prjct - DO NOT EDIT -->",
+          "<!-- This file provides local state persistence for AI tools -->",
+          "",
+          "# prjct State",
+          ""
+        ];
+        if (state.currentTask) {
+          const task = state.currentTask;
+          lines.push("## Current Task");
+          lines.push("");
+          lines.push(`**${task.description}**`);
+          lines.push("");
+          lines.push(`- Started: ${task.startedAt}`);
+          if (task.linearId) {
+            lines.push(`- Linear: ${task.linearId}`);
+          }
+          if (task.branch) {
+            lines.push(`- Branch: ${task.branch}`);
+          }
+          lines.push(`- Status: ${task.status || "active"}`);
+          lines.push("");
+          if (task.subtasks && task.subtasks.length > 0) {
+            lines.push("### Subtasks");
+            lines.push("");
+            task.subtasks.forEach((subtask, index) => {
+              const statusIcon = subtask.status === "completed" ? "\u2705" : subtask.status === "in_progress" ? "\u25B6\uFE0F" : "\u23F3";
+              const isActive = index === task.currentSubtaskIndex ? " \u2190 **Active**" : "";
+              lines.push(`${index + 1}. ${statusIcon} ${subtask.description}${isActive}`);
+            });
+            lines.push("");
+            const completed = task.subtasks.filter((s) => s.status === "completed").length;
+            const total = task.subtasks.length;
+            const percentage = Math.round(completed / total * 100);
+            lines.push(`**Progress**: ${completed}/${total} (${percentage}%)`);
+            lines.push("");
+          }
+        } else {
+          lines.push("*No active task*");
+          lines.push("");
+          lines.push('Start a task with `p. task "description"`');
+          lines.push("");
+        }
+        if (state.previousTask) {
+          const prevTask = state.previousTask;
+          lines.push("---");
+          lines.push("");
+          lines.push("## Previous Task");
+          lines.push("");
+          lines.push(`**${prevTask.description}**`);
+          lines.push("");
+          lines.push(`- Status: ${prevTask.status}`);
+          if (prevTask.prUrl) {
+            lines.push(`- PR: ${prevTask.prUrl}`);
+          }
+          lines.push("");
+        }
+        lines.push("---");
+        lines.push(`*Last updated: ${state.lastUpdated || (/* @__PURE__ */ new Date()).toISOString()}*`);
+        lines.push("");
+        return lines.join("\n");
+      }
+    };
+    localStateGenerator = new LocalStateGenerator();
+  }
+});
+
+// core/services/stack-detector.ts
+import fs41 from "node:fs/promises";
+import path43 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -20251,8 +20365,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path42.join(this.projectPath, "package.json");
-          const content = await fs40.readFile(pkgPath, "utf-8");
+          const pkgPath = path43.join(this.projectPath, "package.json");
+          const content = await fs41.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -20263,7 +20377,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs40.access(path42.join(this.projectPath, filename));
+          await fs41.access(path43.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -20275,8 +20389,8 @@ var init_stack_detector = __esm({
 
 // core/services/sync-service.ts
 import { exec as exec11 } from "node:child_process";
-import fs41 from "node:fs/promises";
-import path43 from "node:path";
+import fs42 from "node:fs/promises";
+import path44 from "node:path";
 import { promisify as promisify11 } from "node:util";
 var execAsync6, SyncService, syncService;
 var init_sync_service = __esm({
@@ -20289,6 +20403,7 @@ var init_sync_service = __esm({
     init_metrics_storage();
     init_date_helper();
     init_context_generator();
+    init_local_state_generator();
     init_stack_detector();
     execAsync6 = promisify11(exec11);
     SyncService = class {
@@ -20425,7 +20540,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs41.mkdir(path43.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs42.mkdir(path44.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -20495,7 +20610,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path43.basename(this.projectPath),
+          name: path44.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -20511,8 +20626,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path43.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs41.readFile(pkgPath, "utf-8"));
+          const pkgPath = path44.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs42.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -20620,12 +20735,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path43.join(this.globalPath, "agents");
+        const agentsPath = path44.join(this.globalPath, "agents");
         try {
-          const files = await fs41.readdir(agentsPath);
+          const files = await fs42.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs41.unlink(path43.join(agentsPath, file));
+              await fs42.unlink(path44.join(agentsPath, file));
             }
           }
         } catch {
@@ -20665,7 +20780,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path43.join(
+          const templatePath = path44.join(
             __dirname,
             "..",
             "..",
@@ -20674,16 +20789,16 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs41.readFile(templatePath, "utf-8");
+          content = await fs42.readFile(templatePath, "utf-8");
         } catch {
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs41.writeFile(path43.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs42.writeFile(path44.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path43.join(
+          const templatePath = path44.join(
             __dirname,
             "..",
             "..",
@@ -20692,14 +20807,14 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs41.readFile(templatePath, "utf-8");
+          content = await fs42.readFile(templatePath, "utf-8");
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
           content = content.replace("{ecosystem}", stats.ecosystem);
         } catch {
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs41.writeFile(path43.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs42.writeFile(path44.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -20767,8 +20882,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
           })),
           agentSkillMap: Object.fromEntries(skills.map((s) => [s.agent, s.skill]))
         };
-        fs41.writeFile(
-          path43.join(this.globalPath, "config", "skills.json"),
+        fs42.writeFile(
+          path44.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch(() => {
@@ -20790,10 +20905,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path43.join(this.globalPath, "project.json");
+        const projectJsonPath = path44.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs41.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs42.readFile(projectJsonPath, "utf-8"));
         } catch {
         }
         const updated = {
@@ -20815,16 +20930,16 @@ You are the ${name} expert for this project. Apply best practices for the detect
           lastSyncCommit: git.recentCommits[0]?.hash || null,
           lastSyncBranch: git.branch
         };
-        await fs41.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs42.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path43.join(this.globalPath, "storage", "state.json");
+        const statePath = path44.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs41.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs42.readFile(statePath, "utf-8"));
         } catch {
         }
         state.projectId = this.projectId;
@@ -20851,13 +20966,20 @@ You are the ${name} expert for this project. Apply best practices for the detect
           lastAction: "Synced project",
           nextAction: 'Run `p. task "description"` to start working'
         };
-        await fs41.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs42.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        try {
+          await localStateGenerator.generate(
+            this.projectPath,
+            state
+          );
+        } catch {
+        }
       }
       // ==========================================================================
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path43.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path44.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: date_helper_default.getTimestamp(),
           action: "sync",
@@ -20866,7 +20988,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs41.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs42.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -20886,16 +21008,16 @@ You are the ${name} expert for this project. Apply best practices for the detect
         let filteredChars = 0;
         for (const file of contextFiles) {
           try {
-            const filePath = path43.join(this.globalPath, file);
-            const content = await fs41.readFile(filePath, "utf-8");
+            const filePath = path44.join(this.globalPath, file);
+            const content = await fs42.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
         }
         for (const agent of agents) {
           try {
-            const agentPath = path43.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs41.readFile(agentPath, "utf-8");
+            const agentPath = path44.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs42.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
@@ -20927,7 +21049,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs41.access(path43.join(this.projectPath, filename));
+          await fs42.access(path44.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -20935,8 +21057,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path43.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs41.readFile(pkgPath, "utf-8"));
+          const pkgPath = path44.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs42.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch {
           return "0.0.0";
@@ -21097,22 +21219,22 @@ __export(uninstall_exports, {
 });
 import { execSync as execSync5 } from "node:child_process";
 import fsSync2 from "node:fs";
-import fs42 from "node:fs/promises";
+import fs43 from "node:fs/promises";
 import os12 from "node:os";
-import path44 from "node:path";
+import path45 from "node:path";
 import readline2 from "node:readline";
 import chalk9 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs42.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs43.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path44.join(dirPath, entry.name);
+      const entryPath = path45.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs42.stat(entryPath);
+          const stats = await fs43.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -21131,7 +21253,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs42.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs43.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -21164,7 +21286,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = fsSync2.existsSync(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path44.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path45.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -21174,7 +21296,7 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path44.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path45.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = fsSync2.existsSync(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
@@ -21208,7 +21330,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path44.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path45.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = fsSync2.existsSync(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -21224,7 +21346,7 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path44.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path45.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = fsSync2.existsSync(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
@@ -21246,7 +21368,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs42.readFile(filePath, "utf-8");
+    const content = await fs43.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -21255,9 +21377,9 @@ async function removePrjctSection(filePath) {
     let newContent = content.substring(0, startIndex) + content.substring(endIndex);
     newContent = newContent.replace(/\n{3,}/g, "\n\n").trim();
     if (!newContent || newContent.trim().length === 0) {
-      await fs42.unlink(filePath);
+      await fs43.unlink(filePath);
     } else {
-      await fs42.writeFile(filePath, `${newContent}
+      await fs43.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -21268,12 +21390,12 @@ async function removePrjctSection(filePath) {
 async function createBackup() {
   const homeDir = os12.homedir();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
-  const backupDir = path44.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path45.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs42.mkdir(backupDir, { recursive: true });
+    await fs43.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (fsSync2.existsSync(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path44.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path45.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -21281,15 +21403,15 @@ async function createBackup() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs42.mkdir(dest, { recursive: true });
-  const entries = await fs42.readdir(src, { withFileTypes: true });
+  await fs43.mkdir(dest, { recursive: true });
+  const entries = await fs43.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path44.join(src, entry.name);
-    const destPath = path44.join(dest, entry.name);
+    const srcPath = path45.join(src, entry.name);
+    const destPath = path45.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs42.copyFile(srcPath, destPath);
+      await fs43.copyFile(srcPath, destPath);
     }
   }
 }
@@ -21305,10 +21427,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs42.rm(item.path, { recursive: true, force: true });
+        await fs43.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs42.unlink(item.path);
+        await fs43.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -21483,7 +21605,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path45 from "node:path";
+import path46 from "node:path";
 import chalk10 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -21688,7 +21810,7 @@ ${chalk10.dim(`[${timestamp}]`)} ${chalk10.cyan("\u27F3")} ${filesSummary} chang
       printStartup() {
         console.log("");
         console.log(chalk10.cyan("\u{1F441}\uFE0F  Watching for changes..."));
-        console.log(chalk10.dim(`   Project: ${path45.basename(this.projectPath)}`));
+        console.log(chalk10.dim(`   Project: ${path46.basename(this.projectPath)}`));
         console.log(chalk10.dim(`   Debounce: ${this.options.debounceMs}ms`));
         console.log(chalk10.dim(`   Min interval: ${this.options.minIntervalMs / 1e3}s`));
         console.log("");
@@ -22361,9 +22483,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync6 } from "node:child_process";
-import fs43 from "node:fs";
+import fs44 from "node:fs";
 import os13 from "node:os";
-import path46 from "node:path";
+import path47 from "node:path";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
   try {
@@ -22469,12 +22591,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path46.join(os13.homedir(), ".gemini", "commands");
-    const routerSource = path46.join(getPackageRoot(), "templates", "commands", "p.toml");
-    const routerDest = path46.join(geminiCommandsDir, "p.toml");
-    fs43.mkdirSync(geminiCommandsDir, { recursive: true });
-    if (fs43.existsSync(routerSource)) {
-      fs43.copyFileSync(routerSource, routerDest);
+    const geminiCommandsDir = path47.join(os13.homedir(), ".gemini", "commands");
+    const routerSource = path47.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = path47.join(geminiCommandsDir, "p.toml");
+    fs44.mkdirSync(geminiCommandsDir, { recursive: true });
+    if (fs44.existsSync(routerSource)) {
+      fs44.copyFileSync(routerSource, routerDest);
       return true;
     }
     return false;
@@ -22485,15 +22607,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path46.join(os13.homedir(), ".gemini");
-    const globalConfigPath = path46.join(geminiDir, "GEMINI.md");
-    const templatePath = path46.join(getPackageRoot(), "templates", "global", "GEMINI.md");
-    fs43.mkdirSync(geminiDir, { recursive: true });
-    const templateContent = fs43.readFileSync(templatePath, "utf-8");
+    const geminiDir = path47.join(os13.homedir(), ".gemini");
+    const globalConfigPath = path47.join(geminiDir, "GEMINI.md");
+    const templatePath = path47.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    fs44.mkdirSync(geminiDir, { recursive: true });
+    const templateContent = fs44.readFileSync(templatePath, "utf-8");
     let existingContent = "";
     let fileExists2 = false;
     try {
-      existingContent = fs43.readFileSync(globalConfigPath, "utf-8");
+      existingContent = fs44.readFileSync(globalConfigPath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -22503,7 +22625,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!fileExists2) {
-      fs43.writeFileSync(globalConfigPath, templateContent, "utf-8");
+      fs44.writeFileSync(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -22513,7 +22635,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      fs43.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
+      fs44.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -22525,7 +22647,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    fs43.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    fs44.writeFileSync(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -22534,18 +22656,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path46.join(os13.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = path46.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = path46.join(prjctSkillDir, "SKILL.md");
-    const templatePath = path46.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
-    fs43.mkdirSync(prjctSkillDir, { recursive: true });
-    const fileExists2 = fs43.existsSync(skillMdPath);
-    if (!fs43.existsSync(templatePath)) {
+    const antigravitySkillsDir = path47.join(os13.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path47.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path47.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path47.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    fs44.mkdirSync(prjctSkillDir, { recursive: true });
+    const fileExists2 = fs44.existsSync(skillMdPath);
+    if (!fs44.existsSync(templatePath)) {
       console.error("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = fs43.readFileSync(templatePath, "utf-8");
-    fs43.writeFileSync(skillMdPath, templateContent, "utf-8");
+    const templateContent = fs44.readFileSync(templatePath, "utf-8");
+    fs44.writeFileSync(skillMdPath, templateContent, "utf-8");
     return { success: true, action: fileExists2 ? "updated" : "created" };
   } catch (error) {
     console.error(`Antigravity skill warning: ${error.message}`);
@@ -22564,24 +22686,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = path46.join(projectRoot, ".cursor");
-    const rulesDir = path46.join(cursorDir, "rules");
-    const commandsDir = path46.join(cursorDir, "commands");
-    const routerMdcDest = path46.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = path46.join(getPackageRoot(), "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = path46.join(getPackageRoot(), "templates", "cursor", "commands");
-    fs43.mkdirSync(rulesDir, { recursive: true });
-    fs43.mkdirSync(commandsDir, { recursive: true });
-    if (fs43.existsSync(routerMdcSource)) {
-      fs43.copyFileSync(routerMdcSource, routerMdcDest);
+    const cursorDir = path47.join(projectRoot, ".cursor");
+    const rulesDir = path47.join(cursorDir, "rules");
+    const commandsDir = path47.join(cursorDir, "commands");
+    const routerMdcDest = path47.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path47.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path47.join(getPackageRoot(), "templates", "cursor", "commands");
+    fs44.mkdirSync(rulesDir, { recursive: true });
+    fs44.mkdirSync(commandsDir, { recursive: true });
+    if (fs44.existsSync(routerMdcSource)) {
+      fs44.copyFileSync(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
-    if (fs43.existsSync(cursorCommandsSource)) {
-      const commandFiles = fs43.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
+    if (fs44.existsSync(cursorCommandsSource)) {
+      const commandFiles = fs44.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path46.join(cursorCommandsSource, file);
-        const dest = path46.join(commandsDir, file);
-        fs43.copyFileSync(src, dest);
+        const src = path47.join(cursorCommandsSource, file);
+        const dest = path47.join(commandsDir, file);
+        fs44.copyFileSync(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -22595,7 +22717,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path46.join(projectRoot, ".gitignore");
+    const gitignorePath = path47.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -22610,7 +22732,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs43.readFileSync(gitignorePath, "utf-8");
+      content = fs44.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -22625,7 +22747,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs43.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs44.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -22633,12 +22755,12 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasCursorProject(projectRoot) {
-  return fs43.existsSync(path46.join(projectRoot, ".cursor"));
+  return fs44.existsSync(path47.join(projectRoot, ".cursor"));
 }
 function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path46.join(projectRoot, ".cursor");
-  const routerPath = path46.join(cursorDir, "rules", "prjct.mdc");
-  return fs43.existsSync(cursorDir) && !fs43.existsSync(routerPath);
+  const cursorDir = path47.join(projectRoot, ".cursor");
+  const routerPath = path47.join(cursorDir, "rules", "prjct.mdc");
+  return fs44.existsSync(cursorDir) && !fs44.existsSync(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
   const result = {
@@ -22648,29 +22770,29 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = path46.join(projectRoot, ".windsurf");
-    const rulesDir = path46.join(windsurfDir, "rules");
-    const workflowsDir = path46.join(windsurfDir, "workflows");
-    const routerDest = path46.join(rulesDir, "prjct.md");
-    const routerSource = path46.join(getPackageRoot(), "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = path46.join(
+    const windsurfDir = path47.join(projectRoot, ".windsurf");
+    const rulesDir = path47.join(windsurfDir, "rules");
+    const workflowsDir = path47.join(windsurfDir, "workflows");
+    const routerDest = path47.join(rulesDir, "prjct.md");
+    const routerSource = path47.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path47.join(
       getPackageRoot(),
       "templates",
       "windsurf",
       "workflows"
     );
-    fs43.mkdirSync(rulesDir, { recursive: true });
-    fs43.mkdirSync(workflowsDir, { recursive: true });
-    if (fs43.existsSync(routerSource)) {
-      fs43.copyFileSync(routerSource, routerDest);
+    fs44.mkdirSync(rulesDir, { recursive: true });
+    fs44.mkdirSync(workflowsDir, { recursive: true });
+    if (fs44.existsSync(routerSource)) {
+      fs44.copyFileSync(routerSource, routerDest);
       result.rulesCreated = true;
     }
-    if (fs43.existsSync(windsurfWorkflowsSource)) {
-      const workflowFiles = fs43.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
+    if (fs44.existsSync(windsurfWorkflowsSource)) {
+      const workflowFiles = fs44.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
       for (const file of workflowFiles) {
-        const src = path46.join(windsurfWorkflowsSource, file);
-        const dest = path46.join(workflowsDir, file);
-        fs43.copyFileSync(src, dest);
+        const src = path47.join(windsurfWorkflowsSource, file);
+        const dest = path47.join(workflowsDir, file);
+        fs44.copyFileSync(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -22684,7 +22806,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path46.join(projectRoot, ".gitignore");
+    const gitignorePath = path47.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -22699,7 +22821,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs43.readFileSync(gitignorePath, "utf-8");
+      content = fs44.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -22714,7 +22836,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs43.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs44.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -22722,32 +22844,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasWindsurfProject(projectRoot) {
-  return fs43.existsSync(path46.join(projectRoot, ".windsurf"));
+  return fs44.existsSync(path47.join(projectRoot, ".windsurf"));
 }
 function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path46.join(projectRoot, ".windsurf");
-  const routerPath = path46.join(windsurfDir, "rules", "prjct.md");
-  return fs43.existsSync(windsurfDir) && !fs43.existsSync(routerPath);
+  const windsurfDir = path47.join(projectRoot, ".windsurf");
+  const routerPath = path47.join(windsurfDir, "rules", "prjct.md");
+  return fs44.existsSync(windsurfDir) && !fs44.existsSync(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path46.join(os13.homedir(), ".prjct-cli", "projects");
-    if (!fs43.existsSync(projectsDir)) {
+    const projectsDir = path47.join(os13.homedir(), ".prjct-cli", "projects");
+    if (!fs44.existsSync(projectsDir)) {
       return;
     }
-    const projectDirs = fs43.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = fs44.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path46.join(projectsDir, projectId, "project.json");
-      if (!fs43.existsSync(projectJsonPath)) {
+      const projectJsonPath = path47.join(projectsDir, projectId, "project.json");
+      if (!fs44.existsSync(projectJsonPath)) {
         continue;
       }
       try {
-        const content = fs43.readFileSync(projectJsonPath, "utf8");
+        const content = fs44.readFileSync(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          fs43.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          fs44.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -22767,9 +22889,9 @@ async function migrateProjectsCliVersion() {
 }
 function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
-  if (fs43.existsSync(settingsPath)) {
+  if (fs44.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs43.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(fs44.readFileSync(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -22777,42 +22899,42 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  fs43.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  fs44.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path46.join(os13.homedir(), ".claude");
-    const settingsPath = path46.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = path46.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path46.join(os13.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = path46.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = path46.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = path46.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = path46.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = path46.join(prjctStatusLineDir, "config.json");
-    const assetsDir = path46.join(getPackageRoot(), "assets", "statusline");
-    const sourceScript = path46.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = path46.join(assetsDir, "themes");
-    const sourceLibDir = path46.join(assetsDir, "lib");
-    const sourceComponentsDir = path46.join(assetsDir, "components");
-    const sourceConfigPath = path46.join(assetsDir, "default-config.json");
-    if (!fs43.existsSync(claudeDir)) {
-      fs43.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = path47.join(os13.homedir(), ".claude");
+    const settingsPath = path47.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path47.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path47.join(os13.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path47.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path47.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path47.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path47.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path47.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path47.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = path47.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path47.join(assetsDir, "themes");
+    const sourceLibDir = path47.join(assetsDir, "lib");
+    const sourceComponentsDir = path47.join(assetsDir, "components");
+    const sourceConfigPath = path47.join(assetsDir, "default-config.json");
+    if (!fs44.existsSync(claudeDir)) {
+      fs44.mkdirSync(claudeDir, { recursive: true });
     }
-    if (!fs43.existsSync(prjctStatusLineDir)) {
-      fs43.mkdirSync(prjctStatusLineDir, { recursive: true });
+    if (!fs44.existsSync(prjctStatusLineDir)) {
+      fs44.mkdirSync(prjctStatusLineDir, { recursive: true });
     }
-    if (!fs43.existsSync(prjctThemesDir)) {
-      fs43.mkdirSync(prjctThemesDir, { recursive: true });
+    if (!fs44.existsSync(prjctThemesDir)) {
+      fs44.mkdirSync(prjctThemesDir, { recursive: true });
     }
-    if (!fs43.existsSync(prjctLibDir)) {
-      fs43.mkdirSync(prjctLibDir, { recursive: true });
+    if (!fs44.existsSync(prjctLibDir)) {
+      fs44.mkdirSync(prjctLibDir, { recursive: true });
     }
-    if (!fs43.existsSync(prjctComponentsDir)) {
-      fs43.mkdirSync(prjctComponentsDir, { recursive: true });
+    if (!fs44.existsSync(prjctComponentsDir)) {
+      fs44.mkdirSync(prjctComponentsDir, { recursive: true });
     }
-    if (fs43.existsSync(prjctStatusLinePath)) {
-      const existingContent = fs43.readFileSync(prjctStatusLinePath, "utf8");
+    if (fs44.existsSync(prjctStatusLinePath)) {
+      const existingContent = fs44.readFileSync(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -22820,7 +22942,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          fs43.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+          fs44.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         installStatusLineModules(sourceLibDir, prjctLibDir);
         installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -22829,22 +22951,22 @@ async function installStatusLine() {
         return;
       }
     }
-    if (fs43.existsSync(sourceScript)) {
-      let scriptContent = fs43.readFileSync(sourceScript, "utf8");
+    if (fs44.existsSync(sourceScript)) {
+      let scriptContent = fs44.readFileSync(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      fs43.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs44.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
       installStatusLineModules(sourceLibDir, prjctLibDir);
       installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (fs43.existsSync(sourceThemeDir)) {
-        const themes = fs43.readdirSync(sourceThemeDir);
+      if (fs44.existsSync(sourceThemeDir)) {
+        const themes = fs44.readdirSync(sourceThemeDir);
         for (const theme of themes) {
-          const src = path46.join(sourceThemeDir, theme);
-          const dest = path46.join(prjctThemesDir, theme);
-          fs43.copyFileSync(src, dest);
+          const src = path47.join(sourceThemeDir, theme);
+          const dest = path47.join(prjctThemesDir, theme);
+          fs44.copyFileSync(src, dest);
         }
       }
-      if (!fs43.existsSync(prjctConfigPath) && fs43.existsSync(sourceConfigPath)) {
-        fs43.copyFileSync(sourceConfigPath, prjctConfigPath);
+      if (!fs44.existsSync(prjctConfigPath) && fs44.existsSync(sourceConfigPath)) {
+        fs44.copyFileSync(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -22879,7 +23001,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      fs43.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs44.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -22891,10 +23013,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path46.join(os13.homedir(), ".claude");
-    const mcpConfigPath = path46.join(claudeDir, "mcp.json");
-    if (!fs43.existsSync(claudeDir)) {
-      fs43.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = path47.join(os13.homedir(), ".claude");
+    const mcpConfigPath = path47.join(claudeDir, "mcp.json");
+    if (!fs44.existsSync(claudeDir)) {
+      fs44.mkdirSync(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -22904,54 +23026,54 @@ async function installContext7MCP() {
         }
       }
     };
-    if (fs43.existsSync(mcpConfigPath)) {
-      const existingContent = fs43.readFileSync(mcpConfigPath, "utf-8");
+    if (fs44.existsSync(mcpConfigPath)) {
+      const existingContent = fs44.readFileSync(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      fs43.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      fs44.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      fs43.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      fs44.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     console.error(`Context7 MCP setup warning: ${error.message}`);
   }
 }
 function installStatusLineModules(sourceDir, destDir) {
-  if (!fs43.existsSync(sourceDir)) {
+  if (!fs44.existsSync(sourceDir)) {
     return;
   }
-  const files = fs43.readdirSync(sourceDir);
+  const files = fs44.readdirSync(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path46.join(sourceDir, file);
-      const dest = path46.join(destDir, file);
-      fs43.copyFileSync(src, dest);
-      fs43.chmodSync(dest, 493);
+      const src = path47.join(sourceDir, file);
+      const dest = path47.join(destDir, file);
+      fs44.copyFileSync(src, dest);
+      fs44.chmodSync(dest, 493);
     }
   }
 }
 function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
-    if (fs43.existsSync(linkPath)) {
-      const stats = fs43.lstatSync(linkPath);
+    if (fs44.existsSync(linkPath)) {
+      const stats = fs44.lstatSync(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = fs43.readlinkSync(linkPath);
+        const existingTarget = fs44.readlinkSync(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      fs43.unlinkSync(linkPath);
+      fs44.unlinkSync(linkPath);
     }
-    fs43.symlinkSync(targetPath, linkPath);
+    fs44.symlinkSync(targetPath, linkPath);
   } catch (_error) {
     try {
-      if (fs43.existsSync(targetPath)) {
-        fs43.copyFileSync(targetPath, linkPath);
-        fs43.chmodSync(linkPath, 493);
+      if (fs44.existsSync(targetPath)) {
+        fs44.copyFileSync(targetPath, linkPath);
+        fs44.chmodSync(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -23366,7 +23488,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path47 from "node:path";
+import path48 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -23392,7 +23514,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path47.basename(projectPath);
+          const projectName = path48.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -23644,8 +23766,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs44 from "node:fs/promises";
-import path48 from "node:path";
+import fs45 from "node:fs/promises";
+import path49 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -23771,8 +23893,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path48.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs44.readFile(analysisPath, "utf-8");
+          const analysisPath = path49.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs45.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -23791,7 +23913,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path49 from "node:path";
+import path50 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -23807,7 +23929,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path49.basename(filePath));
+          results.rotated.push(path50.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -23914,7 +24036,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path50 from "node:path";
+import path51 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -23926,7 +24048,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
     const designTarget = target || "system";
     output_default.spin(`designing ${designType}...`);
     const projectId = await config_manager_default.getProjectId(projectPath);
-    const designsPath = path50.join(
+    const designsPath = path51.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -23966,7 +24088,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path50.join(designsPath, designFileName);
+    const designFilePath = path51.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -23990,7 +24112,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path51 from "node:path";
+import path52 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -24042,7 +24164,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path51.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path52.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync7 } = await import("node:child_process");
     try {
@@ -24060,7 +24182,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path51.join(snapshotsPath, "history.json");
+      const snapshotFile = path52.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -24100,8 +24222,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path51.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path51.join(snapshotsPath, "history.json");
+    const snapshotsPath = path52.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path52.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -24160,8 +24282,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path51.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path51.join(snapshotsPath, "history.json");
+    const snapshotsPath = path52.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path52.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -24268,8 +24390,8 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import fs45 from "node:fs";
-import path52 from "node:path";
+import fs46 from "node:fs";
+import path53 from "node:path";
 import chalk11 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -24396,7 +24518,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path52.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path53.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -24454,11 +24576,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs45.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs46.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs45.existsSync(settingsPath)) {
+          if (fs46.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs45.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs46.readFileSync(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -24466,7 +24588,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs45.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs46.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -24522,18 +24644,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path53 from "node:path";
+import path54 from "node:path";
 async function detectPackageManager(projectPath, pkg) {
   const declared = pkg?.packageManager?.trim().toLowerCase();
   if (declared?.startsWith("pnpm@")) return "pnpm";
   if (declared?.startsWith("yarn@")) return "yarn";
   if (declared?.startsWith("bun@")) return "bun";
   if (declared?.startsWith("npm@")) return "npm";
-  if (await fileExists(path53.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path53.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists(path53.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists(path53.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists(path53.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(path54.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path54.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path54.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path54.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path54.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -24549,7 +24671,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path53.join(projectPath, "package.json");
+  const pkgPath = path54.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -24566,27 +24688,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path53.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path54.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path53.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path54.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path53.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path54.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path53.join(projectPath, "go.mod"))) {
+  if (await fileExists(path54.join(projectPath, "go.mod"))) {
     return { stack: "go", test: { tool: "go", command: "go test ./..." } };
   }
   const files = await listFiles(projectPath);
   if (files.some((f) => f.endsWith(".sln") || f.endsWith(".csproj") || f.endsWith(".fsproj"))) {
     return { stack: "dotnet", test: { tool: "dotnet", command: "dotnet test" } };
   }
-  if (await fileExists(path53.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path54.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path53.join(projectPath, "gradlew")) && (await fileExists(path53.join(projectPath, "build.gradle")) || await fileExists(path53.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path54.join(projectPath, "gradlew")) && (await fileExists(path54.join(projectPath, "build.gradle")) || await fileExists(path54.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -24763,7 +24885,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path54 from "node:path";
+import path55 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -24909,7 +25031,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path54.join(projectPath, "package.json");
+          const pkgPath = path55.join(projectPath, "package.json");
           const pkg = await file_helper_exports.readJson(pkgPath, { version: "0.0.0" });
           const oldVersion = pkg?.version || "0.0.0";
           const [major, minor, patch] = oldVersion.split(".").map(Number);
@@ -24931,7 +25053,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path54.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path55.join(projectPath, "CHANGELOG.md");
           const changelog = await file_helper_exports.readFile(changelogPath, "# Changelog\n\n");
           const entry = `## [${version}] - ${date_helper_default.formatDate(/* @__PURE__ */ new Date())}
 
@@ -25823,19 +25945,19 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs46 from "node:fs";
+import fs47 from "node:fs";
 import os14 from "node:os";
-import path55 from "node:path";
+import path56 from "node:path";
 function getCredentialsPath(projectId) {
-  return path55.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path56.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
-  if (!fs46.existsSync(credPath)) {
+  if (!fs47.existsSync(credPath)) {
     return {};
   }
   try {
-    return JSON.parse(fs46.readFileSync(credPath, "utf-8"));
+    return JSON.parse(fs47.readFileSync(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", error.message);
     return {};
@@ -26412,7 +26534,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.60.1",
+      version: "0.61.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -26519,9 +26641,9 @@ var require_package = __commonJS({
 
 // core/index.ts
 var core_exports = {};
-import fs47 from "node:fs";
+import fs48 from "node:fs";
 import os15 from "node:os";
-import path56 from "node:path";
+import path57 from "node:path";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
   if (["-v", "--version", "version"].includes(commandName)) {
@@ -26653,12 +26775,12 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 function displayVersion(version) {
   const detection = detectAllProviders();
-  const claudeCommandPath = path56.join(os15.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path56.join(os15.homedir(), ".gemini", "commands", "p.toml");
-  const claudeConfigured = fs47.existsSync(claudeCommandPath);
-  const geminiConfigured = fs47.existsSync(geminiCommandPath);
-  const cursorConfigured = fs47.existsSync(path56.join(process.cwd(), ".cursor", "commands", "sync.md"));
-  const cursorExists = fs47.existsSync(path56.join(process.cwd(), ".cursor"));
+  const claudeCommandPath = path57.join(os15.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path57.join(os15.homedir(), ".gemini", "commands", "p.toml");
+  const claudeConfigured = fs48.existsSync(claudeCommandPath);
+  const geminiConfigured = fs48.existsSync(geminiCommandPath);
+  const cursorConfigured = fs48.existsSync(path57.join(process.cwd(), ".cursor", "commands", "sync.md"));
+  const cursorExists = fs48.existsSync(path57.join(process.cwd(), ".cursor"));
   console.log(`
 ${CYAN3}p/${RESET5} prjct v${version}
 ${DIM6}Context layer for AI coding agents${RESET5}
@@ -26791,9 +26913,9 @@ var init_core = __esm({
 init_ai_provider();
 init_config_manager();
 init_editors_config();
-import fs48 from "node:fs";
+import fs49 from "node:fs";
 import os16 from "node:os";
-import path57 from "node:path";
+import path58 from "node:path";
 
 // core/server/server.ts
 import { Hono as Hono3 } from "hono";
@@ -27535,14 +27657,14 @@ function checkRoutersInstalled() {
   const home = os16.homedir();
   const detection = detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path57.join(home, ".claude", "commands", "p.md");
-    if (!fs48.existsSync(claudeRouter)) {
+    const claudeRouter = path58.join(home, ".claude", "commands", "p.md");
+    if (!fs49.existsSync(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path57.join(home, ".gemini", "commands", "p.toml");
-    if (!fs48.existsSync(geminiRouter)) {
+    const geminiRouter = path58.join(home, ".gemini", "commands", "p.toml");
+    if (!fs49.existsSync(geminiRouter)) {
       return false;
     }
   }
@@ -27643,7 +27765,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path57.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path58.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -27662,12 +27784,12 @@ if (args[0] === "start" || args[0] === "setup") {
   const detection = detectAllProviders();
   const home = os16.homedir();
   const cwd = process.cwd();
-  const claudeConfigured = fs48.existsSync(path57.join(home, ".claude", "commands", "p.md"));
-  const geminiConfigured = fs48.existsSync(path57.join(home, ".gemini", "commands", "p.toml"));
-  const cursorDetected = fs48.existsSync(path57.join(cwd, ".cursor"));
-  const cursorConfigured = fs48.existsSync(path57.join(cwd, ".cursor", "rules", "prjct.mdc"));
-  const windsurfDetected = fs48.existsSync(path57.join(cwd, ".windsurf"));
-  const windsurfConfigured = fs48.existsSync(path57.join(cwd, ".windsurf", "rules", "prjct.md"));
+  const claudeConfigured = fs49.existsSync(path58.join(home, ".claude", "commands", "p.md"));
+  const geminiConfigured = fs49.existsSync(path58.join(home, ".gemini", "commands", "p.toml"));
+  const cursorDetected = fs49.existsSync(path58.join(cwd, ".cursor"));
+  const cursorConfigured = fs49.existsSync(path58.join(cwd, ".cursor", "rules", "prjct.mdc"));
+  const windsurfDetected = fs49.existsSync(path58.join(cwd, ".windsurf"));
+  const windsurfConfigured = fs49.existsSync(path58.join(cwd, ".windsurf", "rules", "prjct.md"));
   const GREEN7 = "\x1B[32m";
   console.log(`
 ${CYAN4}p/${RESET6} prjct v${VERSION}
@@ -27706,9 +27828,9 @@ ${DIM7}Run 'prjct init' to configure (Cursor/Windsurf IDE)${RESET6}
 ${CYAN4}https://prjct.app${RESET6}
 `);
 } else {
-  const configPath = path57.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path58.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = checkRoutersInstalled();
-  if (!fs48.existsSync(configPath) || !routersInstalled) {
+  if (!fs49.existsSync(configPath) || !routersInstalled) {
     console.log(`
 ${CYAN4}${BOLD4}  Welcome to prjct!${RESET6}