npm - prjct-cli - Versions diffs - 0.60.2 → 0.62.0 - Mend

prjct-cli 0.60.2 → 0.62.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/CHANGELOG.md +73 -0
package/core/__tests__/services/dependency-validator.test.ts +175 -0
package/core/infrastructure/setup.ts +24 -1
package/core/services/dependency-validator.ts +318 -0
package/core/services/git-analyzer.ts +28 -11
package/core/services/local-state-generator.ts +158 -0
package/core/services/skill-installer.ts +14 -1
package/core/services/sync-service.ts +11 -0
package/core/storage/state-storage.ts +3 -0
package/dist/bin/prjct.mjs +708 -320
package/dist/core/infrastructure/setup.js +274 -7
package/package.json +1 -1

package/dist/bin/prjct.mjs CHANGED Viewed

@@ -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")
@@ -15594,6 +15594,249 @@ var init_file_scorer = __esm({
   }
 });
+// core/services/dependency-validator.ts
+import { execSync as execSync4 } from "node:child_process";
+var TOOLS, DependencyValidator, DependencyError, dependencyValidator;
+var init_dependency_validator = __esm({
+  "core/services/dependency-validator.ts"() {
+    "use strict";
+    init_error_messages();
+    TOOLS = {
+      git: {
+        name: "git",
+        command: "git --version",
+        versionRegex: /git version ([\d.]+)/,
+        required: true,
+        installHint: "Install Git: https://git-scm.com/downloads",
+        docs: "https://git-scm.com/doc"
+      },
+      node: {
+        name: "node",
+        command: "node --version",
+        versionRegex: /v([\d.]+)/,
+        required: true,
+        installHint: "Install Node.js: https://nodejs.org",
+        docs: "https://nodejs.org/docs"
+      },
+      bun: {
+        name: "bun",
+        command: "bun --version",
+        versionRegex: /([\d.]+)/,
+        required: false,
+        installHint: "Install Bun: curl -fsSL https://bun.sh/install | bash",
+        docs: "https://bun.sh/docs"
+      },
+      gh: {
+        name: "gh",
+        command: "gh --version",
+        versionRegex: /gh version ([\d.]+)/,
+        required: false,
+        installHint: "Install GitHub CLI: https://cli.github.com",
+        docs: "https://cli.github.com/manual"
+      },
+      npm: {
+        name: "npm",
+        command: "npm --version",
+        versionRegex: /([\d.]+)/,
+        required: false,
+        installHint: "npm comes with Node.js: https://nodejs.org"
+      },
+      claude: {
+        name: "claude",
+        command: "claude --version",
+        versionRegex: /claude ([\d.]+)/,
+        required: false,
+        installHint: "Install Claude Code: npm install -g @anthropic-ai/claude-code",
+        docs: "https://docs.anthropic.com/claude-code"
+      },
+      gemini: {
+        name: "gemini",
+        command: "gemini --version",
+        versionRegex: /gemini ([\d.]+)/,
+        required: false,
+        installHint: "Install Gemini CLI: npm install -g @google/gemini-cli",
+        docs: "https://ai.google.dev/gemini-api/docs"
+      }
+    };
+    DependencyValidator = class {
+      static {
+        __name(this, "DependencyValidator");
+      }
+      cache = /* @__PURE__ */ new Map();
+      cacheTimeout = 6e4;
+      // 1 minute cache
+      cacheTimestamps = /* @__PURE__ */ new Map();
+      /**
+       * Check if a tool is available
+       * Uses caching to avoid repeated execSync calls
+       */
+      checkTool(toolName) {
+        const cached = this.getCached(toolName);
+        if (cached) return cached;
+        const definition = TOOLS[toolName];
+        if (!definition) {
+          return this.checkUnknownTool(toolName);
+        }
+        const status = this.executeCheck(definition);
+        this.setCache(toolName, status);
+        return status;
+      }
+      /**
+       * Ensure a tool is available, throw helpful error if not
+       * Use this before operations that require a specific tool
+       */
+      ensureTool(toolName) {
+        const status = this.checkTool(toolName);
+        if (!status.available) {
+          const definition = TOOLS[toolName];
+          const error = status.error || {
+            message: `${toolName} is not available`,
+            hint: definition?.installHint || `Install ${toolName} and try again`,
+            docs: definition?.docs
+          };
+          throw new DependencyError(error);
+        }
+      }
+      /**
+       * Ensure multiple tools are available
+       */
+      ensureTools(toolNames) {
+        const missing = [];
+        for (const name of toolNames) {
+          const status = this.checkTool(name);
+          if (!status.available) {
+            missing.push(name);
+          }
+        }
+        if (missing.length > 0) {
+          const hints = missing.map((name) => {
+            const def = TOOLS[name];
+            return def ? `  ${name}: ${def.installHint}` : `  ${name}: Install and try again`;
+          }).join("\n");
+          throw new DependencyError({
+            message: `Missing required tools: ${missing.join(", ")}`,
+            hint: `Install the following:
+${hints}`
+          });
+        }
+      }
+      /**
+       * Check if tool is available (boolean convenience method)
+       */
+      isAvailable(toolName) {
+        return this.checkTool(toolName).available;
+      }
+      /**
+       * Get tool version if available
+       */
+      getVersion(toolName) {
+        return this.checkTool(toolName).version;
+      }
+      /**
+       * Check multiple tools and return summary
+       */
+      checkAll(toolNames) {
+        const names = toolNames || Object.keys(TOOLS);
+        const results = /* @__PURE__ */ new Map();
+        for (const name of names) {
+          results.set(name, this.checkTool(name));
+        }
+        return results;
+      }
+      /**
+       * Clear the cache (useful for tests or after installations)
+       */
+      clearCache() {
+        this.cache.clear();
+        this.cacheTimestamps.clear();
+      }
+      // ==========================================================================
+      // PRIVATE METHODS
+      // ==========================================================================
+      executeCheck(definition) {
+        try {
+          const output = execSync4(definition.command, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 5e3
+            // 5 second timeout
+          });
+          let version;
+          if (definition.versionRegex) {
+            const match = output.match(definition.versionRegex);
+            version = match ? match[1] : void 0;
+          }
+          return { available: true, version };
+        } catch {
+          return {
+            available: false,
+            error: createError(
+              `${definition.name} is not installed or not in PATH`,
+              definition.installHint,
+              { docs: definition.docs }
+            )
+          };
+        }
+      }
+      checkUnknownTool(toolName) {
+        try {
+          execSync4(`${toolName} --version`, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 5e3
+          });
+          return { available: true };
+        } catch {
+          try {
+            execSync4(`${toolName} -v`, {
+              encoding: "utf-8",
+              stdio: ["pipe", "pipe", "pipe"],
+              timeout: 5e3
+            });
+            return { available: true };
+          } catch {
+            return {
+              available: false,
+              error: createError(
+                `${toolName} is not installed or not in PATH`,
+                `Install ${toolName} and try again`
+              )
+            };
+          }
+        }
+      }
+      getCached(toolName) {
+        const timestamp = this.cacheTimestamps.get(toolName);
+        if (!timestamp) return null;
+        if (Date.now() - timestamp > this.cacheTimeout) {
+          this.cache.delete(toolName);
+          this.cacheTimestamps.delete(toolName);
+          return null;
+        }
+        return this.cache.get(toolName) || null;
+      }
+      setCache(toolName, status) {
+        this.cache.set(toolName, status);
+        this.cacheTimestamps.set(toolName, Date.now());
+      }
+    };
+    DependencyError = class extends Error {
+      static {
+        __name(this, "DependencyError");
+      }
+      hint;
+      docs;
+      constructor(error) {
+        super(error.message);
+        this.name = "DependencyError";
+        this.hint = error.hint;
+        this.docs = error.docs;
+      }
+    };
+    dependencyValidator = new DependencyValidator();
+  }
+});
 // core/services/git-analyzer.ts
 import { exec as exec6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
@@ -15601,6 +15844,7 @@ var execAsync2;
 var init_git_analyzer = __esm({
   "core/services/git-analyzer.ts"() {
     "use strict";
+    init_dependency_validator();
     execAsync2 = promisify6(exec6);
   }
 });
@@ -16758,16 +17002,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";
@@ -16803,32 +17047,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 {
         }
@@ -16838,17 +17082,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";
@@ -18944,8 +19188,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");
@@ -19567,7 +19811,7 @@ var init_formatters = __esm({
 });
 // core/ai-tools/registry.ts
-import { execSync as execSync4 } from "node:child_process";
+import { execSync as execSync5 } from "node:child_process";
 import fs37 from "node:fs";
 import os11 from "node:os";
 import path39 from "node:path";
@@ -19576,7 +19820,7 @@ function getAIToolConfig(id) {
 }
 function commandExists(cmd) {
   try {
-    execSync4(`which ${cmd}`, { stdio: "ignore" });
+    execSync5(`which ${cmd}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -20088,9 +20332,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"() {
@@ -20249,8 +20609,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;
@@ -20261,7 +20621,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;
@@ -20273,8 +20633,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({
@@ -20287,6 +20647,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 {
@@ -20423,7 +20784,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 }))
         );
       }
       // ==========================================================================
@@ -20493,7 +20854,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: [],
@@ -20509,8 +20870,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";
@@ -20618,12 +20979,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 {
@@ -20663,7 +21024,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path43.join(
+          const templatePath = path44.join(
             __dirname,
             "..",
             "..",
@@ -20672,16 +21033,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,
             "..",
             "..",
@@ -20690,14 +21051,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 = {
@@ -20765,8 +21126,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(() => {
@@ -20788,10 +21149,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 = {
@@ -20813,16 +21174,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;
@@ -20849,13 +21210,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",
@@ -20864,7 +21232,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");
       }
       // ==========================================================================
@@ -20884,16 +21252,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 {
           }
@@ -20925,7 +21293,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;
@@ -20933,8 +21301,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";
@@ -21093,24 +21461,24 @@ __export(uninstall_exports, {
   UninstallCommands: () => UninstallCommands,
   uninstall: () => uninstall
 });
-import { execSync as execSync5 } from "node:child_process";
+import { execSync as execSync6 } 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 {
         }
@@ -21129,7 +21497,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;
@@ -21141,7 +21509,7 @@ function detectInstallation() {
     npm: false
   };
   try {
-    const result = execSync5("brew list prjct-cli 2>/dev/null", { encoding: "utf-8" });
+    const result = execSync6("brew list prjct-cli 2>/dev/null", { encoding: "utf-8" });
     if (result) {
       info.homebrew = true;
       info.homebrewFormula = "prjct-cli";
@@ -21149,7 +21517,7 @@ function detectInstallation() {
   } catch {
   }
   try {
-    const result = execSync5("npm list -g prjct-cli --depth=0 2>/dev/null", { encoding: "utf-8" });
+    const result = execSync6("npm list -g prjct-cli --depth=0 2>/dev/null", { encoding: "utf-8" });
     if (result.includes("prjct-cli")) {
       info.npm = true;
     }
@@ -21162,7 +21530,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,
@@ -21172,7 +21540,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) {
@@ -21206,7 +21574,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,
@@ -21222,7 +21590,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) {
@@ -21244,7 +21612,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;
     }
@@ -21253,9 +21621,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;
@@ -21266,12 +21634,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 {
@@ -21279,15 +21647,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);
     }
   }
 }
@@ -21303,10 +21671,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) {
@@ -21317,7 +21685,7 @@ async function performUninstall(items, installation, options) {
     if (installation.homebrew && installation.homebrewFormula) {
       try {
         if (!options.dryRun) {
-          execSync5(`brew uninstall ${installation.homebrewFormula}`, { stdio: "pipe" });
+          execSync6(`brew uninstall ${installation.homebrewFormula}`, { stdio: "pipe" });
         }
         deleted.push("Homebrew: prjct-cli");
       } catch (error) {
@@ -21327,7 +21695,7 @@ async function performUninstall(items, installation, options) {
     if (installation.npm) {
       try {
         if (!options.dryRun) {
-          execSync5("npm uninstall -g prjct-cli", { stdio: "pipe" });
+          execSync6("npm uninstall -g prjct-cli", { stdio: "pipe" });
         }
         deleted.push("npm: prjct-cli");
       } catch (error) {
@@ -21481,7 +21849,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;
@@ -21686,7 +22054,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("");
@@ -22358,16 +22726,28 @@ __export(setup_exports, {
   needsWindsurfRegeneration: () => needsWindsurfRegeneration,
   run: () => run
 });
-import { execSync as execSync6 } from "node:child_process";
-import fs43 from "node:fs";
+import { execSync as execSync7 } from "node:child_process";
+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";
+  if (!dependencyValidator.isAvailable("npm")) {
+    console.log(`${YELLOW4}\u26A0\uFE0F  npm is not available${NC}`);
+    console.log("");
+    console.log(`${DIM4}Install ${provider.displayName} using one of:${NC}`);
+    console.log(`${DIM4}  \u2022 Install Node.js: https://nodejs.org${NC}`);
+    console.log(
+      `${DIM4}  \u2022 Use Homebrew: brew install ${provider.name === "claude" ? "claude" : "gemini"}${NC}`
+    );
+    console.log(`${DIM4}  \u2022 Use npx directly: npx ${packageName}${NC}`);
+    console.log("");
+    return false;
+  }
   try {
     console.log(`${YELLOW4}\u{1F4E6} ${provider.displayName} not found. Installing...${NC}`);
     console.log("");
-    execSync6(`npm install -g ${packageName}`, { stdio: "inherit" });
+    execSync7(`npm install -g ${packageName}`, { stdio: "inherit" });
     console.log("");
     console.log(`${GREEN4}\u2713${NC} ${provider.displayName} installed successfully`);
     console.log("");
@@ -22376,7 +22756,14 @@ async function installAICLI(provider) {
     console.log(
       `${YELLOW4}\u26A0\uFE0F  Failed to install ${provider.displayName}: ${error.message}${NC}`
     );
-    console.log(`${DIM4}Please install manually: npm install -g ${packageName}${NC}`);
+    console.log("");
+    console.log(`${DIM4}Alternative installation methods:${NC}`);
+    console.log(`${DIM4}  \u2022 npm:  npm install -g ${packageName}${NC}`);
+    console.log(`${DIM4}  \u2022 yarn: yarn global add ${packageName}${NC}`);
+    console.log(`${DIM4}  \u2022 pnpm: pnpm add -g ${packageName}${NC}`);
+    console.log(
+      `${DIM4}  \u2022 brew: brew install ${provider.name === "claude" ? "claude" : "gemini"}${NC}`
+    );
     console.log("");
     return false;
   }
@@ -22467,12 +22854,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;
@@ -22483,15 +22870,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)) {
@@ -22501,7 +22888,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 -->";
@@ -22511,7 +22898,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));
@@ -22523,7 +22910,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}`);
@@ -22532,18 +22919,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}`);
@@ -22562,24 +22949,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;
     }
@@ -22593,7 +22980,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",
@@ -22608,7 +22995,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)) {
@@ -22623,7 +23010,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}`);
@@ -22631,12 +23018,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 = {
@@ -22646,29 +23033,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;
     }
@@ -22682,7 +23069,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",
@@ -22697,7 +23084,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)) {
@@ -22712,7 +23099,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}`);
@@ -22720,32 +23107,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) {
@@ -22765,9 +23152,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;
@@ -22775,42 +23162,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) {
@@ -22818,7 +23205,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);
@@ -22827,22 +23214,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
@@ -22877,7 +23264,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);
@@ -22889,10 +23276,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: {
@@ -22902,54 +23289,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)) {
@@ -22987,6 +23374,7 @@ var GREEN4, YELLOW4, DIM4, NC, setup_default, isDirectRun;
 var init_setup = __esm({
   "core/infrastructure/setup.ts"() {
     "use strict";
+    init_dependency_validator();
     init_fs();
     init_version();
     init_ai_provider();
@@ -23364,7 +23752,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"() {
@@ -23390,7 +23778,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);
@@ -23642,8 +24030,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"() {
@@ -23769,8 +24157,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",
@@ -23789,7 +24177,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 };
@@ -23805,7 +24193,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;
         }
       }
@@ -23912,7 +24300,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";
@@ -23924,7 +24312,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"
@@ -23964,7 +24352,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,
@@ -23988,7 +24376,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);
@@ -24040,11 +24428,11 @@ 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");
+    const { execSync: execSync8 } = await import("node:child_process");
     try {
-      const status = execSync7("git status --porcelain", {
+      const status = execSync8("git status --porcelain", {
         cwd: projectPath,
         encoding: "utf-8"
       }).trim();
@@ -24054,11 +24442,11 @@ async function undo(projectPath = process.cwd()) {
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const stashMessage = `prjct-undo-${timestamp}`;
-      execSync7(`git stash push -m "${stashMessage}"`, {
+      execSync8(`git stash push -m "${stashMessage}"`, {
         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);
@@ -24098,8 +24486,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);
@@ -24115,9 +24503,9 @@ async function redo(projectPath = process.cwd()) {
       output_default.warn("nothing to redo");
       return { success: false, message: "Nothing to redo" };
     }
-    const { execSync: execSync7 } = await import("node:child_process");
+    const { execSync: execSync8 } = await import("node:child_process");
     try {
-      const stashList = execSync7("git stash list", {
+      const stashList = execSync8("git stash list", {
         cwd: projectPath,
         encoding: "utf-8"
       }).trim();
@@ -24130,7 +24518,7 @@ async function redo(projectPath = process.cwd()) {
         output_default.warn("no prjct undo point found");
         return { success: false, message: "No prjct undo point found" };
       }
-      execSync7("git stash pop", {
+      execSync8("git stash pop", {
         cwd: projectPath,
         encoding: "utf-8"
       });
@@ -24158,8 +24546,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);
@@ -24266,8 +24654,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({
@@ -24394,7 +24782,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
@@ -24452,11 +24840,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) {
             }
           }
@@ -24464,7 +24852,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 };
@@ -24520,18 +24908,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) {
@@ -24547,7 +24935,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);
@@ -24564,27 +24952,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" };
@@ -24761,7 +25149,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"() {
@@ -24907,7 +25295,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);
@@ -24929,7 +25317,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())}
@@ -25821,19 +26209,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 {};
@@ -26410,7 +26798,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.60.2",
+      version: "0.62.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -26517,9 +26905,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)) {
@@ -26651,12 +27039,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}
@@ -26789,9 +27177,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";
@@ -27533,14 +27921,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;
     }
   }
@@ -27641,7 +28029,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",
@@ -27660,12 +28048,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}
@@ -27704,9 +28092,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}