prjct-cli 1.5.1 → 1.6.1

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) => (path62) => {
-  var fn = map[path62];
+var __glob = (map) => (path64) => {
+  var fn = map[path64];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path62);
+  throw new Error("Module not found in bundle: " + path64);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -2390,7 +2390,7 @@ var init_output = __esm({
     }, "truncate");
     __name(limitLines, "limitLines");
     __name(formatForHuman, "formatForHuman");
-    clear = /* @__PURE__ */ __name(() => process.stdout.write(`\r${" ".repeat(80)}\r`), "clear");
+    clear = /* @__PURE__ */ __name(() => process.stdout.isTTY ? process.stdout.write(`\r${" ".repeat(80)}\r`) : true, "clear");
     out = {
       // Branding: Show header at start
       start() {
@@ -2403,9 +2403,15 @@ var init_output = __esm({
         return this;
       },
       // Branded spinner: prjct message...
+      // In non-TTY (CI, Claude Code), prints a static line instead of animating
       spin(msg) {
         if (quietMode) return this;
         this.stop();
+        if (!process.stdout.isTTY) {
+          process.stdout.write(`${branding_default.cli.spin(0, truncate(msg, 45))}
+`);
+          return this;
+        }
         interval = setInterval(() => {
           process.stdout.write(`\r${branding_default.cli.spin(frame++, truncate(msg, 45))}`);
         }, SPEED);
@@ -2549,6 +2555,11 @@ ${chalk2.bold(title)}`);
         if (quietMode) return this;
         this.stop();
         const counter = chalk2.dim(`[${current}/${total}]`);
+        if (!process.stdout.isTTY) {
+          process.stdout.write(`${branding_default.cli.spin(0, `${counter} ${truncate(msg, 35)}`)}
+`);
+          return this;
+        }
         interval = setInterval(() => {
           process.stdout.write(`\r${branding_default.cli.spin(frame++, `${counter} ${truncate(msg, 35)}`)}`);
         }, SPEED);
@@ -2563,6 +2574,11 @@ ${chalk2.bold(title)}`);
         const empty = 10 - filled;
         const bar = chalk2.cyan("\u2588".repeat(filled)) + chalk2.dim("\u2591".repeat(empty));
         const text = msg ? ` ${truncate(msg, 25)}` : "";
+        if (!process.stdout.isTTY) {
+          process.stdout.write(`${branding_default.cli.spin(0, `[${bar}] ${percent}%${text}`)}
+`);
+          return this;
+        }
         interval = setInterval(() => {
           process.stdout.write(`\r${branding_default.cli.spin(frame++, `[${bar}] ${percent}%${text}`)}`);
         }, SPEED);
@@ -4259,8 +4275,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 fs51 = __require("node:fs");
+      if (fs51.existsSync(fullPath) && fs51.statSync(fullPath).isFile()) {
         return path13.relative(projectPath, fullPath);
       }
     } catch {
@@ -4753,6 +4769,8 @@ var init_token_counter = __esm({
       // $1/$5 per M
       "claude-opus-4": { input: 0.015, output: 0.075 },
       // $15/$75 per M (legacy)
+      "claude-opus-4-6": { input: 0.015, output: 0.075 },
+      // $15/$75 per M
       // OpenAI
       "gpt-4o": { input: 25e-4, output: 0.01 },
       // $2.50/$10 per M
@@ -4771,6 +4789,7 @@ var init_token_counter = __esm({
     BREAKDOWN_MODELS = [
       "claude-sonnet-4.5",
       "claude-opus-4.5",
+      "claude-opus-4-6",
       "gpt-4o",
       "gemini-1.5-pro"
     ];
@@ -5443,11 +5462,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs49 = await import("node:fs/promises");
-  const path62 = await import("node:path");
-  const fullPath = path62.isAbsolute(filePath) ? filePath : path62.join(projectPath, filePath);
+  const fs51 = await import("node:fs/promises");
+  const path64 = await import("node:path");
+  const fullPath = path64.isAbsolute(filePath) ? filePath : path64.join(projectPath, filePath);
   try {
-    const stat = await fs49.stat(fullPath);
+    const stat = await fs51.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5514,11 +5533,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs49 = await import("node:fs/promises");
-  const path62 = await import("node:path");
-  const fullPath = path62.isAbsolute(targetPath) ? targetPath : path62.join(projectPath, targetPath);
+  const fs51 = await import("node:fs/promises");
+  const path64 = await import("node:path");
+  const fullPath = path64.isAbsolute(targetPath) ? targetPath : path64.join(projectPath, targetPath);
   try {
-    const stat = await fs49.stat(fullPath);
+    const stat = await fs51.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -12246,18 +12265,24 @@ var init_template_loader = __esm({
 });
 
 // core/agentic/orchestrator-executor.ts
+import { exec as execCallback5 } from "node:child_process";
 import fs26 from "node:fs/promises";
 import os8 from "node:os";
 import path25 from "node:path";
-var DOMAIN_KEYWORDS2, DOMAIN_DEPENDENCY_ORDER, OrchestratorExecutor, orchestratorExecutor, orchestrator_executor_default;
+import { promisify as promisify7 } from "node:util";
+var execAsync3, DOMAIN_KEYWORDS2, DOMAIN_DEPENDENCY_ORDER, OrchestratorExecutor, orchestratorExecutor, orchestrator_executor_default;
 var init_orchestrator_executor = __esm({
   "core/agentic/orchestrator-executor.ts"() {
     "use strict";
+    init_files_tool();
+    init_recent_tool();
+    init_signatures_tool();
     init_config_manager();
     init_path_manager();
     init_storage2();
     init_fs();
     init_template_loader();
+    execAsync3 = promisify7(execCallback5);
     DOMAIN_KEYWORDS2 = {
       database: [
         "database",
@@ -12408,6 +12433,7 @@ var init_orchestrator_executor = __esm({
         const { domains, primary } = await this.detectDomains(taskDescription, projectId, repoAnalysis);
         const agents = await this.loadAgents(domains, projectId);
         const skills = await this.loadSkills(agents);
+        const realContext = await this.gatherRealContext(taskDescription, projectPath);
         const requiresFragmentation = this.shouldFragment(domains, taskDescription);
         let subtasks = null;
         if (requiresFragmentation && command === "task") {
@@ -12424,9 +12450,87 @@ var init_orchestrator_executor = __esm({
             id: projectId,
             ecosystem: repoAnalysis?.ecosystem || "unknown",
             conventions: repoAnalysis?.conventions || []
-          }
+          },
+          realContext
         };
       }
+      /**
+       * Gather real codebase context proactively.
+       *
+       * Calls existing context tools (files-tool, recent-tool, signatures-tool)
+       * to build a briefing so the agent doesn't need to explore first.
+       */
+      async gatherRealContext(taskDescription, projectPath) {
+        try {
+          const [gitResult, filesResult, recentResult] = await Promise.all([
+            this.getGitState(projectPath),
+            findRelevantFiles(taskDescription, projectPath, { maxFiles: 10, minScore: 0.15 }),
+            getRecentFiles(projectPath, { commits: 10, maxFiles: 10 })
+          ]);
+          const topFiles = filesResult.files.slice(0, 3);
+          const signatureResults = await Promise.all(
+            topFiles.map(async (f) => {
+              try {
+                const result = await extractSignatures(f.path, projectPath);
+                if (result.signatures.length === 0) return null;
+                const sigContent = result.signatures.map((s) => `${s.exported ? "export " : ""}${s.type} ${s.name}: ${s.signature}`).join("\n");
+                return { path: f.path, content: sigContent };
+              } catch {
+                return null;
+              }
+            })
+          );
+          return {
+            gitBranch: gitResult.branch,
+            gitStatus: gitResult.status,
+            relevantFiles: filesResult.files.map((f) => ({
+              path: f.path,
+              score: Math.round(f.score * 100),
+              reason: f.reasons.join(", ")
+            })),
+            recentFiles: recentResult.hotFiles.slice(0, 5).map((f) => ({
+              path: f.path,
+              lastChanged: f.lastChanged,
+              changes: f.changes
+            })),
+            signatures: signatureResults.filter(
+              (s) => s !== null
+            )
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      /**
+       * Get current git state (branch + short status)
+       */
+      async getGitState(projectPath) {
+        try {
+          const [branchResult, statusResult] = await Promise.all([
+            execAsync3("git branch --show-current", { cwd: projectPath }),
+            execAsync3("git status --porcelain", { cwd: projectPath })
+          ]);
+          const branch = branchResult.stdout.trim() || "main";
+          const lines = statusResult.stdout.trim().split("\n").filter(Boolean);
+          let modified = 0;
+          let untracked = 0;
+          let staged = 0;
+          for (const line of lines) {
+            const code = line.substring(0, 2);
+            if (code.startsWith("??")) untracked++;
+            else if (code[0] !== " " && code[0] !== "?") staged++;
+            else modified++;
+          }
+          const parts = [];
+          if (staged > 0) parts.push(`${staged} staged`);
+          if (modified > 0) parts.push(`${modified} modified`);
+          if (untracked > 0) parts.push(`${untracked} untracked`);
+          const status = parts.length > 0 ? parts.join(", ") : "clean";
+          return { branch, status };
+        } catch {
+          return { branch: "unknown", status: "git unavailable" };
+        }
+      }
       /**
        * Load repo-analysis.json for project context
        */
@@ -12527,7 +12631,9 @@ var init_orchestrator_executor = __esm({
                 domain,
                 content: body,
                 skills: frontmatter.skills || [],
-                filePath
+                filePath,
+                effort: frontmatter.effort,
+                model: frontmatter.model
               };
             } catch {
             }
@@ -12560,13 +12666,15 @@ var init_orchestrator_executor = __esm({
        */
       async loadSkills(agents) {
         const skillsDir = path25.join(os8.homedir(), ".claude", "skills");
-        const uniqueSkillNames = /* @__PURE__ */ new Set();
+        const skillToAgents = /* @__PURE__ */ new Map();
         for (const agent of agents) {
           for (const skillName of agent.skills) {
-            uniqueSkillNames.add(skillName);
+            const existing = skillToAgents.get(skillName) || [];
+            existing.push(agent.name);
+            skillToAgents.set(skillName, existing);
           }
         }
-        const skillPromises = Array.from(uniqueSkillNames).map(
+        const skillPromises = Array.from(skillToAgents.keys()).map(
           async (skillName) => {
             const flatPath = path25.join(skillsDir, `${skillName}.md`);
             const subdirPath = path25.join(skillsDir, skillName, "SKILL.md");
@@ -12578,6 +12686,10 @@ var init_orchestrator_executor = __esm({
                 const content = await fs26.readFile(flatPath, "utf-8");
                 return { name: skillName, content, filePath: flatPath };
               } catch {
+                const agentNames = skillToAgents.get(skillName) || [];
+                console.warn(
+                  `\u26A0 Skill "${skillName}" not installed (needed by: ${agentNames.join(", ")}). Run \`prjct sync\` to auto-install.`
+                );
                 return null;
               }
             }
@@ -13898,6 +14010,10 @@ Apply specialized expertise. Read agent file for details if needed.
             parts.push("### LOADED AGENTS (Project-Specific Specialists)\n\n");
             for (const agent2 of orchestratorContext.agents) {
               parts.push(`#### Agent: ${agent2.name} (${agent2.domain})
+`);
+              if (agent2.effort) parts.push(`Effort: ${agent2.effort}
+`);
+              if (agent2.model) parts.push(`Model: ${agent2.model}
 `);
               if (agent2.skills.length > 0) {
                 parts.push(`Skills: ${agent2.skills.join(", ")}
@@ -13917,12 +14033,47 @@ ${truncatedContent}
             for (const skill of orchestratorContext.skills) {
               parts.push(`#### Skill: ${skill.name}
 `);
-              const truncatedContent = skill.content.length > 1e3 ? `${skill.content.substring(0, 1e3)}
+              const truncatedContent = skill.content.length > 2e3 ? `${skill.content.substring(0, 2e3)}
 ... (truncated)` : skill.content;
               parts.push(`\`\`\`markdown
 ${truncatedContent}
 \`\`\`
 
+`);
+            }
+          }
+          if (orchestratorContext.realContext) {
+            const rc = orchestratorContext.realContext;
+            parts.push("### CODEBASE CONTEXT (Real \u2014 gathered proactively)\n\n");
+            parts.push(`**Git State**: Branch \`${rc.gitBranch}\` | ${rc.gitStatus}
+
+`);
+            if (rc.relevantFiles.length > 0) {
+              parts.push("**Relevant Files** (scored by task relevance):\n");
+              parts.push("| Score | File | Why |\n");
+              parts.push("|-------|------|-----|\n");
+              for (const f of rc.relevantFiles.slice(0, 8)) {
+                parts.push(`| ${f.score} | ${f.path} | ${f.reason} |
+`);
+              }
+              parts.push("\n");
+            }
+            if (rc.signatures.length > 0) {
+              parts.push("**Code Signatures** (top files):\n");
+              for (const sig of rc.signatures) {
+                parts.push(`\`\`\`typescript
+// ${sig.path}
+${sig.content}
+\`\`\`
+`);
+              }
+              parts.push("\n");
+            }
+            if (rc.recentFiles.length > 0) {
+              parts.push("**Recently Changed**: ");
+              const recentSummary = rc.recentFiles.slice(0, 5).map((f) => `${f.path} (${f.lastChanged})`).join(", ");
+              parts.push(`${recentSummary}
+
 `);
             }
           }
@@ -14401,12 +14552,12 @@ When fragmenting tasks:
 // core/agentic/tool-registry.ts
 import { exec as exec7 } from "node:child_process";
 import fs29 from "node:fs/promises";
-import { promisify as promisify7 } from "node:util";
-var execAsync3, toolRegistry, tool_registry_default;
+import { promisify as promisify8 } from "node:util";
+var execAsync4, toolRegistry, tool_registry_default;
 var init_tool_registry = __esm({
   "core/agentic/tool-registry.ts"() {
     "use strict";
-    execAsync3 = promisify7(exec7);
+    execAsync4 = promisify8(exec7);
     toolRegistry = {
       tools: /* @__PURE__ */ new Map(),
       /**
@@ -14461,7 +14612,7 @@ var init_tool_registry = __esm({
       "Bash",
       async (command) => {
         try {
-          const { stdout, stderr } = await execAsync3(command);
+          const { stdout, stderr } = await execAsync4(command);
           return { stdout, stderr };
         } catch (error) {
           const err = error;
@@ -15567,11 +15718,12 @@ var init_breakdown_service = __esm({
 });
 
 // core/services/context-selector.ts
-var DOMAIN_KEYWORDS3, ContextSelector, contextSelector;
+var DEFAULT_TOKEN_BUDGET, DOMAIN_KEYWORDS3, ContextSelector, contextSelector;
 var init_context_selector = __esm({
   "core/services/context-selector.ts"() {
     "use strict";
     init_index_storage();
+    DEFAULT_TOKEN_BUDGET = 8e4;
     DOMAIN_KEYWORDS3 = {
       payments: [
         "payment",
@@ -15694,7 +15846,7 @@ var init_context_selector = __esm({
         const maxFiles = options.maxFiles || 50;
         const minScore = options.minScore || 30;
         const includeGeneral = options.includeGeneral !== false;
-        const tokenBudget = options.tokenBudget || 5e4;
+        const tokenBudget = options.tokenBudget || DEFAULT_TOKEN_BUDGET;
         const [index, domainsData, categoriesCache] = await Promise.all([
           indexStorage.readIndex(projectId),
           indexStorage.readDomains(projectId),
@@ -15820,7 +15972,7 @@ var init_context_selector = __esm({
       fallbackSelection(files, options) {
         const maxFiles = options.maxFiles || 50;
         const minScore = options.minScore || 30;
-        const tokenBudget = options.tokenBudget || 5e4;
+        const tokenBudget = options.tokenBudget || DEFAULT_TOKEN_BUDGET;
         const filteredFiles = files.filter((f) => f.score >= minScore).sort((a, b) => b.score - a.score);
         let estimatedTokens = 0;
         const selectedFiles = [];
@@ -16597,14 +16749,14 @@ ${hints}`
 
 // core/services/git-analyzer.ts
 import { exec as exec8 } from "node:child_process";
-import { promisify as promisify8 } from "node:util";
-var execAsync4;
+import { promisify as promisify9 } from "node:util";
+var execAsync5;
 var init_git_analyzer = __esm({
   "core/services/git-analyzer.ts"() {
     "use strict";
     init_constants();
     init_dependency_validator();
-    execAsync4 = promisify8(exec8);
+    execAsync5 = promisify9(exec8);
   }
 });
 
@@ -17280,15 +17432,15 @@ ${agent.description}`;
 
 // core/services/project-index.ts
 import { exec as exec9 } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
-var execAsync5;
+import { promisify as promisify10 } from "node:util";
+var execAsync6;
 var init_project_index = __esm({
   "core/services/project-index.ts"() {
     "use strict";
     init_index_storage();
     init_date_helper();
     init_file_scorer();
-    execAsync5 = promisify9(exec9);
+    execAsync6 = promisify10(exec9);
   }
 });
 
@@ -17761,16 +17913,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs49 = await import("node:fs/promises");
-        const path62 = await import("node:path");
+        const fs51 = await import("node:fs/promises");
+        const path64 = await import("node:path");
         try {
-          const files = await fs49.readdir(this.projectPath);
+          const files = await fs51.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 = path62.join(this.projectPath, "package.json");
-            const pkgContent = await fs49.readFile(pkgPath, "utf-8");
+            const pkgPath = path64.join(this.projectPath, "package.json");
+            const pkgContent = await fs51.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -17806,32 +17958,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs49 = await import("node:fs/promises");
-        const path62 = await import("node:path");
-        const os17 = await import("node:os");
+        const fs51 = await import("node:fs/promises");
+        const path64 = await import("node:path");
+        const os20 = await import("node:os");
         const agents = [];
         try {
-          await fs49.access(path62.join(os17.homedir(), ".claude"));
+          await fs51.access(path64.join(os20.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs49.access(path62.join(this.projectPath, ".cursorrules"));
+          await fs51.access(path64.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs49.access(path62.join(this.projectPath, ".windsurfrules"));
+          await fs51.access(path64.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs49.access(path62.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs51.access(path64.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs49.access(path62.join(os17.homedir(), ".gemini"));
+          await fs51.access(path64.join(os20.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -17841,17 +17993,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs49 = await import("node:fs/promises");
-        const path62 = await import("node:path");
+        const fs51 = await import("node:fs/promises");
+        const path64 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs49.readdir(this.projectPath);
+          const files = await fs51.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path62.join(this.projectPath, "package.json");
-            const pkgContent = await fs49.readFile(pkgPath, "utf-8");
+            const pkgPath = path64.join(this.projectPath, "package.json");
+            const pkgContent = await fs51.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -17960,7 +18112,7 @@ var init_wizard = __esm({
 import { exec as exec10 } from "node:child_process";
 import fs34 from "node:fs/promises";
 import path36 from "node:path";
-import { promisify as promisify10 } from "node:util";
+import { promisify as promisify11 } from "node:util";
 async function generateContext(projectId, repoPath) {
   const _globalPath = path_manager_default.getGlobalProjectPath(projectId);
   const contextPath = path_manager_default.getContextPath(projectId);
@@ -18018,17 +18170,17 @@ async function getGitData(repoPath) {
     recentCommits: []
   };
   try {
-    const { stdout: branch } = await execAsync6("git branch --show-current", { cwd: repoPath });
+    const { stdout: branch } = await execAsync7("git branch --show-current", { cwd: repoPath });
     data.branch = branch.trim() || "main";
-    const { stdout: commits } = await execAsync6("git rev-list --count HEAD", { cwd: repoPath });
+    const { stdout: commits } = await execAsync7("git rev-list --count HEAD", { cwd: repoPath });
     data.commits = parseInt(commits.trim(), 10) || 0;
-    const { stdout: contributors } = await execAsync6("git shortlog -sn --all | wc -l", {
+    const { stdout: contributors } = await execAsync7("git shortlog -sn --all | wc -l", {
       cwd: repoPath
     });
     data.contributors = parseInt(contributors.trim(), 10) || 0;
-    const { stdout: status } = await execAsync6("git status --porcelain", { cwd: repoPath });
+    const { stdout: status } = await execAsync7("git status --porcelain", { cwd: repoPath });
     data.hasChanges = status.trim().length > 0;
-    const { stdout: log } = await execAsync6(
+    const { stdout: log } = await execAsync7(
       'git log --oneline -10 --pretty=format:"%h|%s|%ad" --date=short',
       { cwd: repoPath }
     );
@@ -18177,13 +18329,13 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 `;
   await fs34.writeFile(path36.join(contextPath, "summary.md"), content, "utf-8");
 }
-var execAsync6;
+var execAsync7;
 var init_generator = __esm({
   "core/context/generator.ts"() {
     "use strict";
     init_path_manager();
     init_storage2();
-    execAsync6 = promisify10(exec10);
+    execAsync7 = promisify11(exec10);
     __name(generateContext, "generateContext");
     __name(getGitData, "getGitData");
     __name(getPackageData, "getPackageData");
@@ -18195,16 +18347,16 @@ var init_generator = __esm({
 });
 
 // core/domain/analyzer.ts
-import { exec as execCallback5 } from "node:child_process";
+import { exec as execCallback6 } from "node:child_process";
 import fs35 from "node:fs/promises";
 import path37 from "node:path";
-import { promisify as promisify11 } from "node:util";
+import { promisify as promisify12 } from "node:util";
 var exec11, CodebaseAnalyzer, analyzer, analyzer_default2;
 var init_analyzer2 = __esm({
   "core/domain/analyzer.ts"() {
     "use strict";
     init_fs();
-    exec11 = promisify11(execCallback5);
+    exec11 = promisify12(execCallback6);
     CodebaseAnalyzer = class {
       static {
         __name(this, "CodebaseAnalyzer");
@@ -19132,6 +19284,11 @@ ${formatFullDiff(diff)}`);
           const skillWord = result.skills.length === 1 ? "skill" : "skills";
           generatedItems.push(`${result.skills.length} ${skillWord}`);
         }
+        const installed = result.skillsInstalled?.filter((s) => s.status === "installed") || [];
+        if (installed.length > 0) {
+          const word = installed.length === 1 ? "skill" : "skills";
+          generatedItems.push(`${installed.length} ${word} auto-installed`);
+        }
         output_default.section("Generated");
         output_default.list(generatedItems, { bullet: "\u2713" });
         console.log("");
@@ -19969,8 +20126,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path39.join(globalPath2, "planning", "specs");
             try {
-              const fs49 = await import("node:fs/promises");
-              const files = await fs49.readdir(specsPath2);
+              const fs51 = await import("node:fs/promises");
+              const files = await fs51.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -20186,14 +20343,14 @@ var init_project_service = __esm({
 import { exec as exec12 } from "node:child_process";
 import fs37 from "node:fs/promises";
 import path40 from "node:path";
-import { promisify as promisify12 } from "node:util";
-var execAsync7, DEFAULT_CONFIG, StalenessChecker, createStalenessChecker;
+import { promisify as promisify13 } from "node:util";
+var execAsync8, DEFAULT_CONFIG, StalenessChecker, createStalenessChecker;
 var init_staleness_checker = __esm({
   "core/services/staleness-checker.ts"() {
     "use strict";
     init_path_manager();
     init_session_tracker();
-    execAsync7 = promisify12(exec12);
+    execAsync8 = promisify13(exec12);
     DEFAULT_CONFIG = {
       commitThreshold: 10,
       dayThreshold: 3,
@@ -20246,7 +20403,7 @@ var init_staleness_checker = __esm({
           status.lastSyncCommit = projectJson.lastSyncCommit || null;
           const lastSync = projectJson.lastSync;
           try {
-            const { stdout } = await execAsync7("git rev-parse --short HEAD", {
+            const { stdout } = await execAsync8("git rev-parse --short HEAD", {
               cwd: this.projectPath
             });
             status.currentCommit = stdout.trim();
@@ -20264,7 +20421,7 @@ var init_staleness_checker = __esm({
             return status;
           }
           try {
-            const { stdout } = await execAsync7(`git rev-list --count ${status.lastSyncCommit}..HEAD`, {
+            const { stdout } = await execAsync8(`git rev-list --count ${status.lastSyncCommit}..HEAD`, {
               cwd: this.projectPath
             });
             status.commitsSinceSync = parseInt(stdout.trim(), 10) || 0;
@@ -20281,7 +20438,7 @@ var init_staleness_checker = __esm({
             );
           }
           try {
-            const { stdout } = await execAsync7(`git diff --name-only ${status.lastSyncCommit}..HEAD`, {
+            const { stdout } = await execAsync8(`git diff --name-only ${status.lastSyncCommit}..HEAD`, {
               cwd: this.projectPath
             });
             status.changedFiles = stdout.trim().split("\n").filter(Boolean);
@@ -20700,13 +20857,13 @@ var init_formatters = __esm({
 import { exec as exec13 } from "node:child_process";
 import os11 from "node:os";
 import path41 from "node:path";
-import { promisify as promisify13 } from "node:util";
+import { promisify as promisify14 } from "node:util";
 function getAIToolConfig(id) {
   return AI_TOOLS[id] || null;
 }
 async function commandExists(cmd) {
   try {
-    await execAsync8(`which ${cmd}`);
+    await execAsync9(`which ${cmd}`);
     return true;
   } catch {
     return false;
@@ -20741,19 +20898,19 @@ async function resolveToolIds(mode, repoPath = process.cwd()) {
   }
   return mode.filter((id) => AI_TOOLS[id]);
 }
-var execAsync8, AI_TOOLS, DEFAULT_AI_TOOLS, SUPPORTED_AI_TOOLS;
+var execAsync9, AI_TOOLS, DEFAULT_AI_TOOLS, SUPPORTED_AI_TOOLS;
 var init_registry = __esm({
   "core/ai-tools/registry.ts"() {
     "use strict";
     init_fs_helpers();
-    execAsync8 = promisify13(exec13);
+    execAsync9 = promisify14(exec13);
     AI_TOOLS = {
       claude: {
         id: "claude",
         name: "Claude Code",
         outputFile: "CLAUDE.md",
         outputPath: "global",
-        maxTokens: 3e3,
+        maxTokens: 6e3,
         format: "detailed",
         description: "Anthropic Claude Code CLI"
       },
@@ -20895,6 +21052,45 @@ var init_ai_tools = __esm({
   }
 });
 
+// core/utils/logger.ts
+function getLogLevel() {
+  const debugEnv = process.env.PRJCT_DEBUG || process.env.DEBUG || "";
+  if (!debugEnv) return { level: -1, name: "disabled" };
+  if (TRUTHY_VALUES.has(debugEnv) || debugEnv.includes("prjct")) {
+    return { level: LEVELS.debug, name: "debug" };
+  }
+  const levelValue = LEVELS[debugEnv] ?? -1;
+  const levelName = levelValue >= 0 ? debugEnv : "disabled";
+  return { level: levelValue, name: levelName };
+}
+function createLogMethod(levelThreshold, prefix, method) {
+  return currentLevel >= levelThreshold ? (...args2) => console[method](prefix, ...args2) : noop;
+}
+var LEVELS, TRUTHY_VALUES, currentLevel, currentLevelName, noop, logger2, logger_default;
+var init_logger = __esm({
+  "core/utils/logger.ts"() {
+    "use strict";
+    LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+    TRUTHY_VALUES = /* @__PURE__ */ new Set(["1", "true", "*"]);
+    __name(getLogLevel, "getLogLevel");
+    ({ level: currentLevel, name: currentLevelName } = getLogLevel());
+    noop = /* @__PURE__ */ __name(() => {
+    }, "noop");
+    __name(createLogMethod, "createLogMethod");
+    logger2 = {
+      error: createLogMethod(LEVELS.error, "[prjct:error]", "error"),
+      warn: createLogMethod(LEVELS.warn, "[prjct:warn]", "warn"),
+      info: createLogMethod(LEVELS.info, "[prjct:info]", "log"),
+      debug: createLogMethod(LEVELS.debug, "[prjct:debug]", "log"),
+      // Check if logging is enabled (useful for expensive log prep)
+      isEnabled: /* @__PURE__ */ __name(() => currentLevel >= 0, "isEnabled"),
+      // Get current level name (pre-computed, no runtime lookup)
+      level: /* @__PURE__ */ __name(() => currentLevelName, "level")
+    };
+    logger_default = logger2;
+  }
+});
+
 // core/services/context-generator.ts
 import fs39 from "node:fs/promises";
 import path43 from "node:path";
@@ -21343,9 +21539,364 @@ var init_local_state_generator = __esm({
   }
 });
 
-// core/services/stack-detector.ts
+// core/services/skill-lock.ts
 import fs41 from "node:fs/promises";
+import os12 from "node:os";
 import path45 from "node:path";
+function getLockFilePath() {
+  return path45.join(os12.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
+}
+function createEmptyLockFile() {
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills: {}
+  };
+}
+async function read() {
+  try {
+    const content = await fs41.readFile(getLockFilePath(), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return createEmptyLockFile();
+  }
+}
+async function write(lockFile) {
+  const lockPath = getLockFilePath();
+  await fs41.mkdir(path45.dirname(lockPath), { recursive: true });
+  lockFile.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs41.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
+}
+async function addEntry(entry) {
+  const lockFile = await read();
+  lockFile.skills[entry.name] = entry;
+  await write(lockFile);
+}
+async function removeEntry(name) {
+  const lockFile = await read();
+  if (!(name in lockFile.skills)) return false;
+  delete lockFile.skills[name];
+  await write(lockFile);
+  return true;
+}
+async function getEntry(name) {
+  const lockFile = await read();
+  return lockFile.skills[name] || null;
+}
+async function getAll() {
+  const lockFile = await read();
+  return lockFile.skills;
+}
+function getPath() {
+  return getLockFilePath();
+}
+var LOCK_FILE_NAME, skillLock;
+var init_skill_lock = __esm({
+  "core/services/skill-lock.ts"() {
+    "use strict";
+    LOCK_FILE_NAME = ".skill-lock.json";
+    __name(getLockFilePath, "getLockFilePath");
+    __name(createEmptyLockFile, "createEmptyLockFile");
+    __name(read, "read");
+    __name(write, "write");
+    __name(addEntry, "addEntry");
+    __name(removeEntry, "removeEntry");
+    __name(getEntry, "getEntry");
+    __name(getAll, "getAll");
+    __name(getPath, "getPath");
+    skillLock = {
+      read,
+      write,
+      addEntry,
+      removeEntry,
+      getEntry,
+      getAll,
+      getPath
+    };
+  }
+});
+
+// core/services/skill-installer.ts
+import { exec as execCallback7 } from "node:child_process";
+import fs42 from "node:fs/promises";
+import os13 from "node:os";
+import path46 from "node:path";
+import { promisify as promisify15 } from "node:util";
+import { glob } from "glob";
+function parseSource(source) {
+  if (source.startsWith("./") || source.startsWith("/") || source.startsWith("~")) {
+    const resolvedPath = source.startsWith("~") ? path46.join(os13.homedir(), source.slice(1)) : path46.resolve(source);
+    return {
+      type: "local",
+      localPath: resolvedPath,
+      url: resolvedPath
+    };
+  }
+  const atIndex = source.indexOf("@");
+  if (atIndex > 0) {
+    const repoPath = source.slice(0, atIndex);
+    const skillName = source.slice(atIndex + 1);
+    const [owner, repo] = repoPath.split("/");
+    if (owner && repo) {
+      return {
+        type: "github",
+        owner,
+        repo,
+        skillName,
+        url: `https://github.com/${owner}/${repo}`
+      };
+    }
+  }
+  const parts = source.split("/");
+  if (parts.length === 2 && parts[0] && parts[1]) {
+    return {
+      type: "github",
+      owner: parts[0],
+      repo: parts[1],
+      url: `https://github.com/${parts[0]}/${parts[1]}`
+    };
+  }
+  throw new Error(
+    `Invalid source format: "${source}". Expected "owner/repo", "owner/repo@skill-name", or "./local-path"`
+  );
+}
+async function discoverSkills(dir) {
+  const skills = [];
+  try {
+    const rootSkill = path46.join(dir, "SKILL.md");
+    await fs42.access(rootSkill);
+    const dirName = path46.basename(dir);
+    skills.push({ name: dirName, filePath: rootSkill });
+  } catch {
+  }
+  const subdirSkills = await glob("*/SKILL.md", { cwd: dir, absolute: true });
+  for (const filePath of subdirSkills) {
+    const name = path46.basename(path46.dirname(filePath));
+    if (!skills.some((s) => s.name === name)) {
+      skills.push({ name, filePath });
+    }
+  }
+  const nestedSkills = await glob("skills/*/SKILL.md", { cwd: dir, absolute: true });
+  for (const filePath of nestedSkills) {
+    const name = path46.basename(path46.dirname(filePath));
+    if (!skills.some((s) => s.name === name)) {
+      skills.push({ name, filePath });
+    }
+  }
+  return skills;
+}
+function injectSourceMetadata(content, source, sha) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const prjctBlock = [
+    `_prjct:`,
+    `  sourceUrl: ${source.url}`,
+    `  sourceType: ${source.type}`,
+    `  installedAt: ${now}`
+  ];
+  if (sha) {
+    prjctBlock.push(`  sha: ${sha}`);
+  }
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---/;
+  const match = content.match(frontmatterRegex);
+  if (match) {
+    let frontmatter = match[1];
+    frontmatter = frontmatter.replace(/\n?_prjct:[\s\S]*?(?=\n[a-zA-Z]|\n---|\s*$)/g, "");
+    const updatedFrontmatter = `${frontmatter.trimEnd()}
+${prjctBlock.join("\n")}`;
+    return content.replace(frontmatterRegex, `---
+${updatedFrontmatter}
+---`);
+  }
+  return `---
+${prjctBlock.join("\n")}
+---
+
+${content}`;
+}
+function getInstallDir() {
+  return path46.join(os13.homedir(), ".claude", "skills");
+}
+async function installSkillFile(sourcePath, name, source, sha) {
+  const installDir = getInstallDir();
+  const targetDir = path46.join(installDir, name);
+  const targetPath = path46.join(targetDir, "SKILL.md");
+  const content = await fs42.readFile(sourcePath, "utf-8");
+  const enrichedContent = injectSourceMetadata(content, source, sha);
+  await fs42.mkdir(targetDir, { recursive: true });
+  await fs42.writeFile(targetPath, enrichedContent, "utf-8");
+  return {
+    name,
+    filePath: targetPath,
+    source,
+    sha
+  };
+}
+async function installFromGitHub(source) {
+  const result = { installed: [], skipped: [], errors: [] };
+  if (!dependencyValidator.isAvailable("git")) {
+    const gitStatus = dependencyValidator.checkTool("git");
+    result.errors.push(
+      `Cannot install from GitHub: git is not available. ${gitStatus.error?.hint || "Install git and try again."}`
+    );
+    return result;
+  }
+  const tmpDir = path46.join(os13.tmpdir(), `prjct-skill-${Date.now()}`);
+  try {
+    const cloneUrl = `https://github.com/${source.owner}/${source.repo}.git`;
+    await exec14(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
+    let sha;
+    try {
+      const { stdout } = await exec14("git rev-parse HEAD", {
+        cwd: tmpDir,
+        timeout: getTimeout("TOOL_CHECK")
+      });
+      sha = stdout.trim();
+    } catch {
+    }
+    const discoveredSkills = await discoverSkills(tmpDir);
+    if (discoveredSkills.length === 0) {
+      result.errors.push(`No SKILL.md files found in ${source.owner}/${source.repo}`);
+      return result;
+    }
+    const skillsToInstall = source.skillName ? discoveredSkills.filter((s) => s.name === source.skillName) : discoveredSkills;
+    if (source.skillName && skillsToInstall.length === 0) {
+      result.errors.push(`Skill "${source.skillName}" not found in ${source.owner}/${source.repo}`);
+      return result;
+    }
+    for (const skill of skillsToInstall) {
+      try {
+        const installed = await installSkillFile(skill.filePath, skill.name, source, sha);
+        const lockEntry = {
+          name: skill.name,
+          source: {
+            type: "github",
+            url: `${source.owner}/${source.repo}`,
+            sha
+          },
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          filePath: installed.filePath
+        };
+        await skillLock.addEntry(lockEntry);
+        result.installed.push(installed);
+      } catch (error) {
+        result.errors.push(`Failed to install ${skill.name}: ${error.message}`);
+      }
+    }
+  } finally {
+    try {
+      await fs42.rm(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  return result;
+}
+async function installFromLocal(source) {
+  const result = { installed: [], skipped: [], errors: [] };
+  const localPath = source.localPath;
+  try {
+    await fs42.access(localPath);
+  } catch {
+    result.errors.push(`Local path not found: ${localPath}`);
+    return result;
+  }
+  const stat = await fs42.stat(localPath);
+  if (stat.isFile()) {
+    const name = path46.basename(path46.dirname(localPath));
+    try {
+      const installed = await installSkillFile(localPath, name, source);
+      const lockEntry = {
+        name,
+        source: { type: "local", url: localPath },
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        filePath: installed.filePath
+      };
+      await skillLock.addEntry(lockEntry);
+      result.installed.push(installed);
+    } catch (error) {
+      result.errors.push(`Failed to install from ${localPath}: ${error.message}`);
+    }
+  } else {
+    const discoveredSkills = await discoverSkills(localPath);
+    if (discoveredSkills.length === 0) {
+      result.errors.push(`No SKILL.md files found in ${localPath}`);
+      return result;
+    }
+    for (const skill of discoveredSkills) {
+      try {
+        const installed = await installSkillFile(skill.filePath, skill.name, source);
+        const lockEntry = {
+          name: skill.name,
+          source: { type: "local", url: localPath },
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          filePath: installed.filePath
+        };
+        await skillLock.addEntry(lockEntry);
+        result.installed.push(installed);
+      } catch (error) {
+        result.errors.push(`Failed to install ${skill.name}: ${error.message}`);
+      }
+    }
+  }
+  return result;
+}
+async function remove(name) {
+  const installDir = getInstallDir();
+  const subdirPath = path46.join(installDir, name);
+  try {
+    await fs42.rm(subdirPath, { recursive: true, force: true });
+  } catch {
+  }
+  const flatPath = path46.join(installDir, `${name}.md`);
+  try {
+    await fs42.rm(flatPath, { force: true });
+  } catch {
+  }
+  return skillLock.removeEntry(name);
+}
+async function install(sourceStr) {
+  const source = parseSource(sourceStr);
+  switch (source.type) {
+    case "github":
+      return installFromGitHub(source);
+    case "local":
+      return installFromLocal(source);
+    default:
+      return {
+        installed: [],
+        skipped: [],
+        errors: [`Unsupported source type: ${source.type}`]
+      };
+  }
+}
+var exec14, skillInstaller;
+var init_skill_installer = __esm({
+  "core/services/skill-installer.ts"() {
+    "use strict";
+    init_constants();
+    init_dependency_validator();
+    init_skill_lock();
+    exec14 = promisify15(execCallback7);
+    __name(parseSource, "parseSource");
+    __name(discoverSkills, "discoverSkills");
+    __name(injectSourceMetadata, "injectSourceMetadata");
+    __name(getInstallDir, "getInstallDir");
+    __name(installSkillFile, "installSkillFile");
+    __name(installFromGitHub, "installFromGitHub");
+    __name(installFromLocal, "installFromLocal");
+    __name(remove, "remove");
+    __name(install, "install");
+    skillInstaller = {
+      install,
+      remove,
+      parseSource,
+      getInstallDir
+    };
+  }
+});
+
+// core/services/stack-detector.ts
+import fs43 from "node:fs/promises";
+import path47 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -21504,8 +22055,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path45.join(this.projectPath, "package.json");
-          const content = await fs41.readFile(pkgPath, "utf-8");
+          const pkgPath = path47.join(this.projectPath, "package.json");
+          const content = await fs43.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -21516,7 +22067,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs41.access(path45.join(this.projectPath, filename));
+          await fs43.access(path47.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -21527,16 +22078,16 @@ var init_stack_detector = __esm({
 });
 
 // core/services/sync-verifier.ts
-import { exec as exec14 } from "node:child_process";
-import fs42 from "node:fs/promises";
-import path46 from "node:path";
-import { promisify as promisify14 } from "node:util";
-var execAsync9, BUILTIN_CHECKS, SyncVerifier, syncVerifier;
+import { exec as exec15 } from "node:child_process";
+import fs44 from "node:fs/promises";
+import path48 from "node:path";
+import { promisify as promisify16 } from "node:util";
+var execAsync10, BUILTIN_CHECKS, SyncVerifier, syncVerifier;
 var init_sync_verifier = __esm({
   "core/services/sync-verifier.ts"() {
     "use strict";
     init_fs();
-    execAsync9 = promisify14(exec14);
+    execAsync10 = promisify16(exec15);
     BUILTIN_CHECKS = {
       /**
        * Verify all expected context files exist after sync
@@ -21546,9 +22097,9 @@ var init_sync_verifier = __esm({
         const expected = ["context/CLAUDE.md"];
         const missing = [];
         for (const file of expected) {
-          const filePath = path46.join(globalPath, file);
+          const filePath = path48.join(globalPath, file);
           try {
-            await fs42.access(filePath);
+            await fs44.access(filePath);
           } catch {
             missing.push(file);
           }
@@ -21569,9 +22120,9 @@ var init_sync_verifier = __esm({
         const jsonFiles = ["storage/state.json"];
         const invalid = [];
         for (const file of jsonFiles) {
-          const filePath = path46.join(globalPath, file);
+          const filePath = path48.join(globalPath, file);
           try {
-            const content = await fs42.readFile(filePath, "utf-8");
+            const content = await fs44.readFile(filePath, "utf-8");
             JSON.parse(content);
           } catch (error) {
             if (!isNotFoundError(error)) {
@@ -21592,7 +22143,7 @@ var init_sync_verifier = __esm({
        */
       async noSensitiveData(globalPath) {
         const start = Date.now();
-        const contextDir = path46.join(globalPath, "context");
+        const contextDir = path48.join(globalPath, "context");
         const patterns = [
           /(?:api[_-]?key|apikey)\s*[:=]\s*['"][^'"]{10,}/i,
           /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{4,}/i,
@@ -21600,10 +22151,10 @@ var init_sync_verifier = __esm({
         ];
         const violations = [];
         try {
-          const files = await fs42.readdir(contextDir);
+          const files = await fs44.readdir(contextDir);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
-            const content = await fs42.readFile(path46.join(contextDir, file), "utf-8");
+            const content = await fs44.readFile(path48.join(contextDir, file), "utf-8");
             for (const pattern of patterns) {
               if (pattern.test(content)) {
                 violations.push(`${file}: potential sensitive data detected`);
@@ -21697,7 +22248,7 @@ var init_sync_verifier = __esm({
           };
         }
         try {
-          const { stdout, stderr } = await execAsync9(command, {
+          const { stdout, stderr } = await execAsync10(command, {
             cwd: projectPath,
             timeout: 3e4
           });
@@ -21723,26 +22274,30 @@ var init_sync_verifier = __esm({
 });
 
 // core/services/sync-service.ts
-import { exec as exec15 } from "node:child_process";
-import fs43 from "node:fs/promises";
-import path47 from "node:path";
-import { promisify as promisify15 } from "node:util";
-var execAsync10, SyncService, syncService;
+import { exec as exec16 } from "node:child_process";
+import fs45 from "node:fs/promises";
+import os14 from "node:os";
+import path49 from "node:path";
+import { promisify as promisify17 } from "node:util";
+var execAsync11, SyncService, syncService;
 var init_sync_service = __esm({
   "core/services/sync-service.ts"() {
     "use strict";
     init_ai_tools();
+    init_errors();
     init_command_installer();
     init_config_manager();
     init_path_manager();
     init_metrics_storage();
     init_citations();
     init_date_helper();
+    init_logger();
     init_context_generator();
     init_local_state_generator();
+    init_skill_installer();
     init_stack_detector();
     init_sync_verifier();
-    execAsync10 = promisify15(exec15);
+    execAsync11 = promisify17(exec16);
     SyncService = class {
       static {
         __name(this, "SyncService");
@@ -21787,6 +22342,7 @@ var init_sync_service = __esm({
               stack: this.emptyStack(),
               agents: [],
               skills: [],
+              skillsInstalled: [],
               contextFiles: [],
               aiTools: [],
               error: "No prjct project. Run p. init first."
@@ -21804,6 +22360,7 @@ var init_sync_service = __esm({
           await ensureDirsPromise;
           const agents = await this.generateAgents(stack, stats);
           const skills = this.configureSkills(agents);
+          const skillsInstalled = await this.autoInstallSkills(agents);
           const sources = this.buildSources(stats, commands);
           const contextFiles = await this.generateContextFiles(git, stats, commands, agents, sources);
           const projectContext = {
@@ -21861,6 +22418,7 @@ var init_sync_service = __esm({
             stack,
             agents,
             skills,
+            skillsInstalled,
             contextFiles,
             aiTools: aiToolResults.map((r) => ({
               toolId: r.toolId,
@@ -21881,6 +22439,7 @@ var init_sync_service = __esm({
             stack: this.emptyStack(),
             agents: [],
             skills: [],
+            skillsInstalled: [],
             contextFiles: [],
             aiTools: [],
             error: error.message
@@ -21893,7 +22452,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs43.mkdir(path47.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs45.mkdir(path49.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -21912,19 +22471,19 @@ var init_sync_service = __esm({
           weeklyCommits: 0
         };
         try {
-          const { stdout: branch } = await execAsync10("git branch --show-current", {
+          const { stdout: branch } = await execAsync11("git branch --show-current", {
             cwd: this.projectPath
           });
           data.branch = branch.trim() || "main";
-          const { stdout: commits } = await execAsync10("git rev-list --count HEAD", {
+          const { stdout: commits } = await execAsync11("git rev-list --count HEAD", {
             cwd: this.projectPath
           });
           data.commits = parseInt(commits.trim(), 10) || 0;
-          const { stdout: contributors } = await execAsync10("git shortlog -sn --all | wc -l", {
+          const { stdout: contributors } = await execAsync11("git shortlog -sn --all | wc -l", {
             cwd: this.projectPath
           });
           data.contributors = parseInt(contributors.trim(), 10) || 0;
-          const { stdout: status } = await execAsync10("git status --porcelain", {
+          const { stdout: status } = await execAsync11("git status --porcelain", {
             cwd: this.projectPath
           });
           const lines = status.trim().split("\n").filter(Boolean);
@@ -21940,7 +22499,7 @@ var init_sync_service = __esm({
               data.untrackedFiles.push(file);
             }
           }
-          const { stdout: log } = await execAsync10(
+          const { stdout: log } = await execAsync11(
             'git log --oneline -20 --pretty=format:"%h|%s|%ad" --date=short',
             { cwd: this.projectPath }
           );
@@ -21948,7 +22507,7 @@ var init_sync_service = __esm({
             const [hash, message, date] = line.split("|");
             return { hash, message, date };
           });
-          const { stdout: weekly } = await execAsync10('git log --oneline --since="1 week ago" | wc -l', {
+          const { stdout: weekly } = await execAsync11('git log --oneline --since="1 week ago" | wc -l', {
             cwd: this.projectPath
           });
           data.weeklyCommits = parseInt(weekly.trim(), 10) || 0;
@@ -21963,14 +22522,14 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path47.basename(this.projectPath),
+          name: path49.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
           frameworks: []
         };
         try {
-          const { stdout } = await execAsync10(
+          const { stdout } = await execAsync11(
             'find . -type f \\( -name "*.js" -o -name "*.ts" -o -name "*.tsx" -o -name "*.py" -o -name "*.go" -o -name "*.rs" \\) -not -path "./node_modules/*" -not -path "./.git/*" | wc -l',
             { cwd: this.projectPath }
           );
@@ -21979,8 +22538,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path47.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs43.readFile(pkgPath, "utf-8"));
+          const pkgPath = path49.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs45.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -22124,12 +22683,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path47.join(this.globalPath, "agents");
+        const agentsPath = path49.join(this.globalPath, "agents");
         try {
-          const files = await fs43.readdir(agentsPath);
+          const files = await fs45.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs43.unlink(path47.join(agentsPath, file));
+              await fs45.unlink(path49.join(agentsPath, file));
             }
           }
         } catch {
@@ -22169,7 +22728,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path47.join(
+          const templatePath = path49.join(
             __dirname,
             "..",
             "..",
@@ -22178,16 +22737,16 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs43.readFile(templatePath, "utf-8");
+          content = await fs45.readFile(templatePath, "utf-8");
         } catch {
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs43.writeFile(path47.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs45.writeFile(path49.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path47.join(
+          const templatePath = path49.join(
             __dirname,
             "..",
             "..",
@@ -22196,14 +22755,14 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs43.readFile(templatePath, "utf-8");
+          content = await fs45.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 fs43.writeFile(path47.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs45.writeFile(path49.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -22271,8 +22830,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]))
         };
-        fs43.writeFile(
-          path47.join(this.globalPath, "config", "skills.json"),
+        fs45.writeFile(
+          path49.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch(() => {
@@ -22280,6 +22839,85 @@ You are the ${name} expert for this project. Apply best practices for the detect
         return skills;
       }
       // ==========================================================================
+      // SKILL AUTO-INSTALLATION
+      // ==========================================================================
+      /**
+       * Auto-install skills from skill-mappings.json for generated agents.
+       * Reads the mapping, checks which packages are needed, and installs missing ones.
+       */
+      async autoInstallSkills(agents) {
+        const results = [];
+        try {
+          const mappingsPath = path49.join(
+            __dirname,
+            "..",
+            "..",
+            "templates",
+            "config",
+            "skill-mappings.json"
+          );
+          const mappingsContent = await fs45.readFile(mappingsPath, "utf-8");
+          const mappings = JSON.parse(mappingsContent);
+          const agentToSkillMap = mappings.agentToSkillMap || {};
+          const packagesToInstall = [];
+          for (const agent of agents) {
+            const mapping = agentToSkillMap[agent.name];
+            if (mapping?.packages) {
+              for (const pkg of mapping.packages) {
+                packagesToInstall.push({ pkg, agent: agent.name });
+              }
+            }
+          }
+          if (packagesToInstall.length === 0) return results;
+          const skillsDir = path49.join(os14.homedir(), ".claude", "skills");
+          for (const { pkg, agent } of packagesToInstall) {
+            const skillName = pkg.split("/").pop() || pkg;
+            const subdirPath = path49.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path49.join(skillsDir, `${skillName}.md`);
+            let alreadyInstalled = false;
+            try {
+              await fs45.access(subdirPath);
+              alreadyInstalled = true;
+            } catch {
+              try {
+                await fs45.access(flatPath);
+                alreadyInstalled = true;
+              } catch {
+              }
+            }
+            if (alreadyInstalled) {
+              results.push({ name: skillName, agent, status: "skipped" });
+              continue;
+            }
+            try {
+              const parts = pkg.split("/");
+              let installSource;
+              if (parts.length === 3) {
+                installSource = `${parts[0]}/${parts[1]}@${parts[2]}`;
+              } else {
+                installSource = pkg;
+              }
+              const installResult = await skillInstaller.install(installSource);
+              if (installResult.installed.length > 0) {
+                results.push({ name: skillName, agent, status: "installed" });
+                logger_default.info(`Installed skill: ${skillName} for agent: ${agent}`);
+              } else if (installResult.errors.length > 0) {
+                results.push({ name: skillName, agent, status: "error" });
+                logger_default.debug(`Failed to install skill ${skillName}`, { errors: installResult.errors });
+              } else {
+                results.push({ name: skillName, agent, status: "skipped" });
+              }
+            } catch (error) {
+              results.push({ name: skillName, agent, status: "error" });
+              logger_default.debug(`Skill install error for ${skillName}`, { error: getErrorMessage(error) });
+            }
+          }
+        } catch (error) {
+          logger_default.debug("Skill auto-installation failed (non-critical)", { error: getErrorMessage(error) });
+        }
+        return results;
+      }
+      // ==========================================================================
       // CONTEXT FILE GENERATION
       // ==========================================================================
       async generateContextFiles(git, stats, commands, agents, sources) {
@@ -22300,10 +22938,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path47.join(this.globalPath, "project.json");
+        const projectJsonPath = path49.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs43.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs45.readFile(projectJsonPath, "utf-8"));
         } catch {
         }
         const updated = {
@@ -22325,16 +22963,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 fs43.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs45.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path47.join(this.globalPath, "storage", "state.json");
+        const statePath = path49.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs43.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs45.readFile(statePath, "utf-8"));
         } catch {
         }
         state.projectId = this.projectId;
@@ -22361,7 +22999,7 @@ 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 fs43.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs45.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
         try {
           await localStateGenerator.generate(
             this.projectPath,
@@ -22374,7 +23012,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path47.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path49.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: date_helper_default.getTimestamp(),
           action: "sync",
@@ -22383,7 +23021,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs43.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs45.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -22403,16 +23041,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 = path47.join(this.globalPath, file);
-            const content = await fs43.readFile(filePath, "utf-8");
+            const filePath = path49.join(this.globalPath, file);
+            const content = await fs45.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
         }
         for (const agent of agents) {
           try {
-            const agentPath = path47.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs43.readFile(agentPath, "utf-8");
+            const agentPath = path49.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs45.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
@@ -22444,7 +23082,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs43.access(path47.join(this.projectPath, filename));
+          await fs45.access(path49.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -22452,8 +23090,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path47.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs43.readFile(pkgPath, "utf-8"));
+          const pkgPath = path49.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs45.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch {
           return "0.0.0";
@@ -22613,22 +23251,22 @@ __export(uninstall_exports, {
   uninstall: () => uninstall
 });
 import { execSync as execSync3 } from "node:child_process";
-import fs44 from "node:fs/promises";
-import os12 from "node:os";
-import path48 from "node:path";
+import fs46 from "node:fs/promises";
+import os15 from "node:os";
+import path50 from "node:path";
 import readline2 from "node:readline";
 import chalk12 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs44.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs46.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path48.join(dirPath, entry.name);
+      const entryPath = path50.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs44.stat(entryPath);
+          const stats = await fs46.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -22647,7 +23285,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs44.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs46.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -22680,7 +23318,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = await fileExists(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path48.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path50.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -22690,12 +23328,12 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path48.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path50.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = await fileExists(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
     try {
-      const content = await fs44.readFile(claudeMdPath, "utf-8");
+      const content = await fs46.readFile(claudeMdPath, "utf-8");
       hasPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -22724,7 +23362,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path48.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path50.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = await fileExists(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -22740,12 +23378,12 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path48.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path50.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = await fileExists(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
     try {
-      const content = await fs44.readFile(geminiMdPath, "utf-8");
+      const content = await fs46.readFile(geminiMdPath, "utf-8");
       hasGeminiPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -22762,7 +23400,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs44.readFile(filePath, "utf-8");
+    const content = await fs46.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -22771,9 +23409,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 fs44.unlink(filePath);
+      await fs46.unlink(filePath);
     } else {
-      await fs44.writeFile(filePath, `${newContent}
+      await fs46.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -22782,14 +23420,14 @@ async function removePrjctSection(filePath) {
   }
 }
 async function createBackup() {
-  const homeDir = os12.homedir();
+  const homeDir = os15.homedir();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
-  const backupDir = path48.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path50.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs44.mkdir(backupDir, { recursive: true });
+    await fs46.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (await fileExists(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path48.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path50.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -22797,15 +23435,15 @@ async function createBackup() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs44.mkdir(dest, { recursive: true });
-  const entries = await fs44.readdir(src, { withFileTypes: true });
+  await fs46.mkdir(dest, { recursive: true });
+  const entries = await fs46.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path48.join(src, entry.name);
-    const destPath = path48.join(dest, entry.name);
+    const srcPath = path50.join(src, entry.name);
+    const destPath = path50.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs44.copyFile(srcPath, destPath);
+      await fs46.copyFile(srcPath, destPath);
     }
   }
 }
@@ -22821,10 +23459,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs44.rm(item.path, { recursive: true, force: true });
+        await fs46.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs44.unlink(item.path);
+        await fs46.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -23000,7 +23638,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path49 from "node:path";
+import path51 from "node:path";
 import chalk13 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -23205,7 +23843,7 @@ ${chalk13.dim(`[${timestamp}]`)} ${chalk13.cyan("\u27F3")} ${filesSummary} chang
       printStartup() {
         console.log("");
         console.log(chalk13.cyan("\u{1F441}\uFE0F  Watching for changes..."));
-        console.log(chalk13.dim(`   Project: ${path49.basename(this.projectPath)}`));
+        console.log(chalk13.dim(`   Project: ${path51.basename(this.projectPath)}`));
         console.log(chalk13.dim(`   Debounce: ${this.options.debounceMs}ms`));
         console.log(chalk13.dim(`   Min interval: ${this.options.minIntervalMs / 1e3}s`));
         console.log("");
@@ -23883,9 +24521,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync4 } from "node:child_process";
-import fs45 from "node:fs/promises";
-import os13 from "node:os";
-import path50 from "node:path";
+import fs47 from "node:fs/promises";
+import os16 from "node:os";
+import path52 from "node:path";
 import chalk15 from "chalk";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
@@ -24024,12 +24662,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path50.join(os13.homedir(), ".gemini", "commands");
-    const routerSource = path50.join(getPackageRoot(), "templates", "commands", "p.toml");
-    const routerDest = path50.join(geminiCommandsDir, "p.toml");
-    await fs45.mkdir(geminiCommandsDir, { recursive: true });
+    const geminiCommandsDir = path52.join(os16.homedir(), ".gemini", "commands");
+    const routerSource = path52.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = path52.join(geminiCommandsDir, "p.toml");
+    await fs47.mkdir(geminiCommandsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs45.copyFile(routerSource, routerDest);
+      await fs47.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -24040,15 +24678,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path50.join(os13.homedir(), ".gemini");
-    const globalConfigPath = path50.join(geminiDir, "GEMINI.md");
-    const templatePath = path50.join(getPackageRoot(), "templates", "global", "GEMINI.md");
-    await fs45.mkdir(geminiDir, { recursive: true });
-    const templateContent = await fs45.readFile(templatePath, "utf-8");
+    const geminiDir = path52.join(os16.homedir(), ".gemini");
+    const globalConfigPath = path52.join(geminiDir, "GEMINI.md");
+    const templatePath = path52.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    await fs47.mkdir(geminiDir, { recursive: true });
+    const templateContent = await fs47.readFile(templatePath, "utf-8");
     let existingContent = "";
     let configExists = false;
     try {
-      existingContent = await fs45.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs47.readFile(globalConfigPath, "utf-8");
       configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -24058,7 +24696,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!configExists) {
-      await fs45.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs47.writeFile(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -24068,7 +24706,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      await fs45.writeFile(globalConfigPath, updatedContent2, "utf-8");
+      await fs47.writeFile(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -24080,7 +24718,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    await fs45.writeFile(globalConfigPath, updatedContent, "utf-8");
+    await fs47.writeFile(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -24089,18 +24727,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path50.join(os13.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = path50.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = path50.join(prjctSkillDir, "SKILL.md");
-    const templatePath = path50.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
-    await fs45.mkdir(prjctSkillDir, { recursive: true });
+    const antigravitySkillsDir = path52.join(os16.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path52.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path52.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path52.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    await fs47.mkdir(prjctSkillDir, { recursive: true });
     const skillExists = await fileExists(skillMdPath);
     if (!await fileExists(templatePath)) {
       console.error("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = await fs45.readFile(templatePath, "utf-8");
-    await fs45.writeFile(skillMdPath, templateContent, "utf-8");
+    const templateContent = await fs47.readFile(templatePath, "utf-8");
+    await fs47.writeFile(skillMdPath, templateContent, "utf-8");
     return { success: true, action: skillExists ? "updated" : "created" };
   } catch (error) {
     console.error(`Antigravity skill warning: ${error.message}`);
@@ -24119,24 +24757,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = path50.join(projectRoot, ".cursor");
-    const rulesDir = path50.join(cursorDir, "rules");
-    const commandsDir = path50.join(cursorDir, "commands");
-    const routerMdcDest = path50.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = path50.join(getPackageRoot(), "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = path50.join(getPackageRoot(), "templates", "cursor", "commands");
-    await fs45.mkdir(rulesDir, { recursive: true });
-    await fs45.mkdir(commandsDir, { recursive: true });
+    const cursorDir = path52.join(projectRoot, ".cursor");
+    const rulesDir = path52.join(cursorDir, "rules");
+    const commandsDir = path52.join(cursorDir, "commands");
+    const routerMdcDest = path52.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path52.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path52.join(getPackageRoot(), "templates", "cursor", "commands");
+    await fs47.mkdir(rulesDir, { recursive: true });
+    await fs47.mkdir(commandsDir, { recursive: true });
     if (await fileExists(routerMdcSource)) {
-      await fs45.copyFile(routerMdcSource, routerMdcDest);
+      await fs47.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
     if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await fs45.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
+      const commandFiles = (await fs47.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path50.join(cursorCommandsSource, file);
-        const dest = path50.join(commandsDir, file);
-        await fs45.copyFile(src, dest);
+        const src = path52.join(cursorCommandsSource, file);
+        const dest = path52.join(commandsDir, file);
+        await fs47.copyFile(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -24150,7 +24788,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path50.join(projectRoot, ".gitignore");
+    const gitignorePath = path52.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -24165,7 +24803,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs45.readFile(gitignorePath, "utf-8");
+      content = await fs47.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -24180,7 +24818,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs45.writeFile(gitignorePath, newContent, "utf-8");
+    await fs47.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -24188,11 +24826,11 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasCursorProject(projectRoot) {
-  return await fileExists(path50.join(projectRoot, ".cursor"));
+  return await fileExists(path52.join(projectRoot, ".cursor"));
 }
 async function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path50.join(projectRoot, ".cursor");
-  const routerPath = path50.join(cursorDir, "rules", "prjct.mdc");
+  const cursorDir = path52.join(projectRoot, ".cursor");
+  const routerPath = path52.join(cursorDir, "rules", "prjct.mdc");
   return await fileExists(cursorDir) && !await fileExists(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
@@ -24203,31 +24841,31 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = path50.join(projectRoot, ".windsurf");
-    const rulesDir = path50.join(windsurfDir, "rules");
-    const workflowsDir = path50.join(windsurfDir, "workflows");
-    const routerDest = path50.join(rulesDir, "prjct.md");
-    const routerSource = path50.join(getPackageRoot(), "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = path50.join(
+    const windsurfDir = path52.join(projectRoot, ".windsurf");
+    const rulesDir = path52.join(windsurfDir, "rules");
+    const workflowsDir = path52.join(windsurfDir, "workflows");
+    const routerDest = path52.join(rulesDir, "prjct.md");
+    const routerSource = path52.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path52.join(
       getPackageRoot(),
       "templates",
       "windsurf",
       "workflows"
     );
-    await fs45.mkdir(rulesDir, { recursive: true });
-    await fs45.mkdir(workflowsDir, { recursive: true });
+    await fs47.mkdir(rulesDir, { recursive: true });
+    await fs47.mkdir(workflowsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs45.copyFile(routerSource, routerDest);
+      await fs47.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
     if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await fs45.readdir(windsurfWorkflowsSource)).filter(
+      const workflowFiles = (await fs47.readdir(windsurfWorkflowsSource)).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of workflowFiles) {
-        const src = path50.join(windsurfWorkflowsSource, file);
-        const dest = path50.join(workflowsDir, file);
-        await fs45.copyFile(src, dest);
+        const src = path52.join(windsurfWorkflowsSource, file);
+        const dest = path52.join(workflowsDir, file);
+        await fs47.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -24241,7 +24879,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path50.join(projectRoot, ".gitignore");
+    const gitignorePath = path52.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -24256,7 +24894,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs45.readFile(gitignorePath, "utf-8");
+      content = await fs47.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -24271,7 +24909,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs45.writeFile(gitignorePath, newContent, "utf-8");
+    await fs47.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -24279,32 +24917,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasWindsurfProject(projectRoot) {
-  return await fileExists(path50.join(projectRoot, ".windsurf"));
+  return await fileExists(path52.join(projectRoot, ".windsurf"));
 }
 async function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path50.join(projectRoot, ".windsurf");
-  const routerPath = path50.join(windsurfDir, "rules", "prjct.md");
+  const windsurfDir = path52.join(projectRoot, ".windsurf");
+  const routerPath = path52.join(windsurfDir, "rules", "prjct.md");
   return await fileExists(windsurfDir) && !await fileExists(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path50.join(os13.homedir(), ".prjct-cli", "projects");
+    const projectsDir = path52.join(os16.homedir(), ".prjct-cli", "projects");
     if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = (await fs45.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await fs47.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path50.join(projectsDir, projectId, "project.json");
+      const projectJsonPath = path52.join(projectsDir, projectId, "project.json");
       if (!await fileExists(projectJsonPath)) {
         continue;
       }
       try {
-        const content = await fs45.readFile(projectJsonPath, "utf8");
+        const content = await fs47.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          await fs45.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await fs47.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -24326,7 +24964,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
   if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(await fs45.readFile(settingsPath, "utf8"));
+      settings = JSON.parse(await fs47.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -24334,42 +24972,42 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  await fs45.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await fs47.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path50.join(os13.homedir(), ".claude");
-    const settingsPath = path50.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = path50.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path50.join(os13.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = path50.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = path50.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = path50.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = path50.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = path50.join(prjctStatusLineDir, "config.json");
-    const assetsDir = path50.join(getPackageRoot(), "assets", "statusline");
-    const sourceScript = path50.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = path50.join(assetsDir, "themes");
-    const sourceLibDir = path50.join(assetsDir, "lib");
-    const sourceComponentsDir = path50.join(assetsDir, "components");
-    const sourceConfigPath = path50.join(assetsDir, "default-config.json");
+    const claudeDir = path52.join(os16.homedir(), ".claude");
+    const settingsPath = path52.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path52.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path52.join(os16.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path52.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path52.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path52.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path52.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path52.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path52.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = path52.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path52.join(assetsDir, "themes");
+    const sourceLibDir = path52.join(assetsDir, "lib");
+    const sourceComponentsDir = path52.join(assetsDir, "components");
+    const sourceConfigPath = path52.join(assetsDir, "default-config.json");
     if (!await fileExists(claudeDir)) {
-      await fs45.mkdir(claudeDir, { recursive: true });
+      await fs47.mkdir(claudeDir, { recursive: true });
     }
     if (!await fileExists(prjctStatusLineDir)) {
-      await fs45.mkdir(prjctStatusLineDir, { recursive: true });
+      await fs47.mkdir(prjctStatusLineDir, { recursive: true });
     }
     if (!await fileExists(prjctThemesDir)) {
-      await fs45.mkdir(prjctThemesDir, { recursive: true });
+      await fs47.mkdir(prjctThemesDir, { recursive: true });
     }
     if (!await fileExists(prjctLibDir)) {
-      await fs45.mkdir(prjctLibDir, { recursive: true });
+      await fs47.mkdir(prjctLibDir, { recursive: true });
     }
     if (!await fileExists(prjctComponentsDir)) {
-      await fs45.mkdir(prjctComponentsDir, { recursive: true });
+      await fs47.mkdir(prjctComponentsDir, { recursive: true });
     }
     if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await fs45.readFile(prjctStatusLinePath, "utf8");
+      const existingContent = await fs47.readFile(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -24377,7 +25015,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          await fs45.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await fs47.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         await installStatusLineModules(sourceLibDir, prjctLibDir);
         await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -24387,21 +25025,21 @@ async function installStatusLine() {
       }
     }
     if (await fileExists(sourceScript)) {
-      let scriptContent = await fs45.readFile(sourceScript, "utf8");
+      let scriptContent = await fs47.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await fs45.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs47.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
       await installStatusLineModules(sourceLibDir, prjctLibDir);
       await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
       if (await fileExists(sourceThemeDir)) {
-        const themes = await fs45.readdir(sourceThemeDir);
+        const themes = await fs47.readdir(sourceThemeDir);
         for (const theme of themes) {
-          const src = path50.join(sourceThemeDir, theme);
-          const dest = path50.join(prjctThemesDir, theme);
-          await fs45.copyFile(src, dest);
+          const src = path52.join(sourceThemeDir, theme);
+          const dest = path52.join(prjctThemesDir, theme);
+          await fs47.copyFile(src, dest);
         }
       }
       if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await fs45.copyFile(sourceConfigPath, prjctConfigPath);
+        await fs47.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -24436,7 +25074,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      await fs45.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs47.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -24448,10 +25086,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path50.join(os13.homedir(), ".claude");
-    const mcpConfigPath = path50.join(claudeDir, "mcp.json");
+    const claudeDir = path52.join(os16.homedir(), ".claude");
+    const mcpConfigPath = path52.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
-      await fs45.mkdir(claudeDir, { recursive: true });
+      await fs47.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -24462,16 +25100,16 @@ async function installContext7MCP() {
       }
     };
     if (await fileExists(mcpConfigPath)) {
-      const existingContent = await fs45.readFile(mcpConfigPath, "utf-8");
+      const existingContent = await fs47.readFile(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      await fs45.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await fs47.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      await fs45.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      await fs47.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     console.error(`Context7 MCP setup warning: ${error.message}`);
@@ -24481,34 +25119,34 @@ async function installStatusLineModules(sourceDir, destDir) {
   if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = await fs45.readdir(sourceDir);
+  const files = await fs47.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path50.join(sourceDir, file);
-      const dest = path50.join(destDir, file);
-      await fs45.copyFile(src, dest);
-      await fs45.chmod(dest, 493);
+      const src = path52.join(sourceDir, file);
+      const dest = path52.join(destDir, file);
+      await fs47.copyFile(src, dest);
+      await fs47.chmod(dest, 493);
     }
   }
 }
 async function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
     if (await fileExists(linkPath)) {
-      const stats = await fs45.lstat(linkPath);
+      const stats = await fs47.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = await fs45.readlink(linkPath);
+        const existingTarget = await fs47.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      await fs45.unlink(linkPath);
+      await fs47.unlink(linkPath);
     }
-    await fs45.symlink(targetPath, linkPath);
+    await fs47.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
       if (await fileExists(targetPath)) {
-        await fs45.copyFile(targetPath, linkPath);
-        await fs45.chmod(linkPath, 493);
+        await fs47.copyFile(targetPath, linkPath);
+        await fs47.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -24922,7 +25560,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path51 from "node:path";
+import path53 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -24948,7 +25586,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path51.basename(projectPath);
+          const projectName = path53.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -25200,8 +25838,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs46 from "node:fs/promises";
-import path52 from "node:path";
+import fs48 from "node:fs/promises";
+import path54 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -25327,8 +25965,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path52.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs46.readFile(analysisPath, "utf-8");
+          const analysisPath = path54.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs48.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -25347,7 +25985,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path53 from "node:path";
+import path55 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -25363,7 +26001,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path53.basename(filePath));
+          results.rotated.push(path55.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -25470,7 +26108,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path54 from "node:path";
+import path56 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -25482,7 +26120,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 = path54.join(
+    const designsPath = path56.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -25522,7 +26160,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path54.join(designsPath, designFileName);
+    const designFilePath = path56.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -25546,7 +26184,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path55 from "node:path";
+import path57 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -25598,7 +26236,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path55.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path57.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync5 } = await import("node:child_process");
     try {
@@ -25616,7 +26254,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path55.join(snapshotsPath, "history.json");
+      const snapshotFile = path57.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -25656,8 +26294,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path55.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path55.join(snapshotsPath, "history.json");
+    const snapshotsPath = path57.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path57.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -25716,8 +26354,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path55.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path55.join(snapshotsPath, "history.json");
+    const snapshotsPath = path57.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path57.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -25824,8 +26462,8 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import fs47 from "node:fs/promises";
-import path56 from "node:path";
+import fs49 from "node:fs/promises";
+import path58 from "node:path";
 import chalk16 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -25953,7 +26591,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path56.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path58.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -26011,11 +26649,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          await fs47.writeFile(statusLinePath, scriptContent, { mode: 493 });
+          await fs49.writeFile(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
           if (await fileExists(settingsPath)) {
             try {
-              settings = JSON.parse(await fs47.readFile(settingsPath, "utf8"));
+              settings = JSON.parse(await fs49.readFile(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -26023,7 +26661,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          await fs47.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+          await fs49.writeFile(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -26079,18 +26717,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path57 from "node:path";
+import path59 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 fileExists2(path57.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists2(path57.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists2(path57.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists2(path57.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists2(path57.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists2(path59.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists2(path59.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists2(path59.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists2(path59.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists2(path59.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -26106,7 +26744,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path57.join(projectPath, "package.json");
+  const pkgPath = path59.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -26123,27 +26761,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists2(path57.join(projectPath, "pytest.ini"))) {
+  if (await fileExists2(path59.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path57.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path59.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists2(path57.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists2(path59.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists2(path57.join(projectPath, "go.mod"))) {
+  if (await fileExists2(path59.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 fileExists2(path57.join(projectPath, "pom.xml"))) {
+  if (await fileExists2(path59.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists2(path57.join(projectPath, "gradlew")) && (await fileExists2(path57.join(projectPath, "build.gradle")) || await fileExists2(path57.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists2(path59.join(projectPath, "gradlew")) && (await fileExists2(path59.join(projectPath, "build.gradle")) || await fileExists2(path59.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -26160,8 +26798,8 @@ var init_project_commands = __esm({
 });
 
 // core/workflow/workflow-preferences.ts
-import { exec as exec16 } from "node:child_process";
-import { promisify as promisify16 } from "node:util";
+import { exec as exec17 } from "node:child_process";
+import { promisify as promisify18 } from "node:util";
 import chalk17 from "chalk";
 function prefKey(hook, command) {
   return `workflow:${hook}_${command}`;
@@ -26233,7 +26871,7 @@ async function runWorkflowHooks(projectId, phase, command, options = {}) {
 ${chalk17.dim(`Running ${phase}-${command}: ${action}`)}`);
   try {
     const startTime = Date.now();
-    await execAsync11(action, {
+    await execAsync12(action, {
       timeout: 6e4,
       cwd: options.projectPath || process.cwd(),
       env: { ...process.env }
@@ -26297,12 +26935,12 @@ Set one: "p. workflow antes de ship corre los tests"`;
   lines.push(chalk17.dim('Remove: "p. workflow quita el hook de ship"'));
   return lines.join("\n");
 }
-var execAsync11, sessionPreferences, oncePreferences;
+var execAsync12, sessionPreferences, oncePreferences;
 var init_workflow_preferences = __esm({
   "core/workflow/workflow-preferences.ts"() {
     "use strict";
     init_memory_system();
-    execAsync11 = promisify16(exec16);
+    execAsync12 = promisify18(exec17);
     sessionPreferences = /* @__PURE__ */ new Map();
     oncePreferences = /* @__PURE__ */ new Map();
     __name(prefKey, "prefKey");
@@ -26316,7 +26954,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path58 from "node:path";
+import path60 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -26462,7 +27100,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path58.join(projectPath, "package.json");
+          const pkgPath = path60.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);
@@ -26484,7 +27122,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path58.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path60.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())}
 
@@ -26583,14 +27221,14 @@ var init_cache2 = __esm({
 });
 
 // core/utils/keychain.ts
-import { exec as exec17 } from "node:child_process";
-import { promisify as promisify17 } from "node:util";
+import { exec as exec18 } from "node:child_process";
+import { promisify as promisify19 } from "node:util";
 async function getCredential(key) {
   if (process.platform !== "darwin") {
     return getEnvFallback(key);
   }
   try {
-    const { stdout } = await execAsync12(
+    const { stdout } = await execAsync13(
       `security find-generic-password -s "${SERVICE_NAME}" -a "${key}" -w 2>/dev/null`
     );
     return stdout.trim() || null;
@@ -26606,11 +27244,11 @@ function getEnvFallback(key) {
   const envVar = envMap[key];
   return process.env[envVar] || null;
 }
-var execAsync12, SERVICE_NAME;
+var execAsync13, SERVICE_NAME;
 var init_keychain = __esm({
   "core/utils/keychain.ts"() {
     "use strict";
-    execAsync12 = promisify17(exec17);
+    execAsync13 = promisify19(exec18);
     SERVICE_NAME = "prjct-cli";
     __name(getCredential, "getCredential");
     __name(getEnvFallback, "getEnvFallback");
@@ -27376,11 +28014,11 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs48 from "node:fs/promises";
-import os14 from "node:os";
-import path59 from "node:path";
+import fs50 from "node:fs/promises";
+import os17 from "node:os";
+import path61 from "node:path";
 function getCredentialsPath(projectId) {
-  return path59.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path61.join(os17.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
@@ -27388,7 +28026,7 @@ async function getProjectCredentials(projectId) {
     return {};
   }
   try {
-    return JSON.parse(await fs48.readFile(credPath, "utf-8"));
+    return JSON.parse(await fs50.readFile(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", error.message);
     return {};
@@ -27966,7 +28604,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.5.1",
+      version: "1.6.1",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -28073,8 +28711,8 @@ var require_package = __commonJS({
 
 // core/index.ts
 var core_exports = {};
-import os15 from "node:os";
-import path60 from "node:path";
+import os18 from "node:os";
+import path62 from "node:path";
 import chalk18 from "chalk";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
@@ -28271,13 +28909,13 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 async function displayVersion(version) {
   const detection = await detectAllProviders();
-  const claudeCommandPath = path60.join(os15.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path60.join(os15.homedir(), ".gemini", "commands", "p.toml");
+  const claudeCommandPath = path62.join(os18.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path62.join(os18.homedir(), ".gemini", "commands", "p.toml");
   const [claudeConfigured, geminiConfigured, cursorConfigured, cursorExists] = await Promise.all([
     fileExists(claudeCommandPath),
     fileExists(geminiCommandPath),
-    fileExists(path60.join(process.cwd(), ".cursor", "commands", "sync.md")),
-    fileExists(path60.join(process.cwd(), ".cursor"))
+    fileExists(path62.join(process.cwd(), ".cursor", "commands", "sync.md")),
+    fileExists(path62.join(process.cwd(), ".cursor"))
   ]);
   const antigravityDetection = await detectAntigravity();
   console.log(`
@@ -28413,8 +29051,8 @@ var init_core = __esm({
 init_ai_provider();
 init_config_manager();
 init_editors_config();
-import os16 from "node:os";
-import path61 from "node:path";
+import os19 from "node:os";
+import path63 from "node:path";
 import chalk19 from "chalk";
 
 // core/server/server.ts
@@ -29155,16 +29793,16 @@ __name(startServer, "startServer");
 init_fs_helpers();
 init_version();
 async function checkRoutersInstalled() {
-  const home = os16.homedir();
+  const home = os19.homedir();
   const detection = await detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path61.join(home, ".claude", "commands", "p.md");
+    const claudeRouter = path63.join(home, ".claude", "commands", "p.md");
     if (!await fileExists(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path61.join(home, ".gemini", "commands", "p.toml");
+    const geminiRouter = path63.join(home, ".gemini", "commands", "p.toml");
     if (!await fileExists(geminiRouter)) {
       return false;
     }
@@ -29292,7 +29930,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path61.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path63.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -29309,7 +29947,7 @@ if (args[0] === "start" || args[0] === "setup") {
   process.exitCode = 0;
 } else if (args[0] === "version" || args[0] === "-v" || args[0] === "--version") {
   const detection = await detectAllProviders();
-  const home = os16.homedir();
+  const home = os19.homedir();
   const cwd = process.cwd();
   const [
     claudeConfigured,
@@ -29319,12 +29957,12 @@ if (args[0] === "start" || args[0] === "setup") {
     windsurfDetected,
     windsurfConfigured
   ] = await Promise.all([
-    fileExists(path61.join(home, ".claude", "commands", "p.md")),
-    fileExists(path61.join(home, ".gemini", "commands", "p.toml")),
-    fileExists(path61.join(cwd, ".cursor")),
-    fileExists(path61.join(cwd, ".cursor", "rules", "prjct.mdc")),
-    fileExists(path61.join(cwd, ".windsurf")),
-    fileExists(path61.join(cwd, ".windsurf", "rules", "prjct.md"))
+    fileExists(path63.join(home, ".claude", "commands", "p.md")),
+    fileExists(path63.join(home, ".gemini", "commands", "p.toml")),
+    fileExists(path63.join(cwd, ".cursor")),
+    fileExists(path63.join(cwd, ".cursor", "rules", "prjct.mdc")),
+    fileExists(path63.join(cwd, ".windsurf")),
+    fileExists(path63.join(cwd, ".windsurf", "rules", "prjct.md"))
   ]);
   console.log(`
 ${chalk19.cyan("p/")} prjct v${VERSION}
@@ -29363,7 +30001,7 @@ ${chalk19.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
 ${chalk19.cyan("https://prjct.app")}
 `);
 } else {
-  const configPath = path61.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path63.join(os19.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = await checkRoutersInstalled();
   if (!await fileExists(configPath) || !routersInstalled) {
     console.log(`