prjct-cli 0.35.0 → 0.35.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) => (path34) => {
-  var fn = map[path34];
+var __glob = (map) => (path35) => {
+  var fn = map[path35];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path34);
+  throw new Error("Module not found in bundle: " + path35);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -5706,7 +5706,7 @@ var init_prompt_builder = __esm({
        * Build a complete prompt for Claude from template, context, and enhancements
        * @deprecated Use buildWithInjection for auto-injected context
        */
-      build(template, context, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null) {
+      build(template, context, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null, orchestratorContext = null) {
         const parts = [];
         this._currentContext = context;
         const commandName = template.frontmatter?.name?.replace("p:", "") || "";
@@ -5737,6 +5737,70 @@ Apply specialized expertise. Read agent file for details if needed.
         }
         parts.push("\n---\n");
         parts.push(template.content);
+        if (orchestratorContext) {
+          parts.push("\n## ORCHESTRATOR CONTEXT\n");
+          parts.push(`**Primary Domain**: ${orchestratorContext.primaryDomain}
+`);
+          parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(", ")}
+`);
+          parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}
+
+`);
+          if (orchestratorContext.agents.length > 0) {
+            parts.push("### LOADED AGENTS (Project-Specific Specialists)\n\n");
+            for (const agent2 of orchestratorContext.agents) {
+              parts.push(`#### Agent: ${agent2.name} (${agent2.domain})
+`);
+              if (agent2.skills.length > 0) {
+                parts.push(`Skills: ${agent2.skills.join(", ")}
+`);
+              }
+              const truncatedContent = agent2.content.length > 1500 ? agent2.content.substring(0, 1500) + "\n... (truncated, read full file for more)" : agent2.content;
+              parts.push(`\`\`\`markdown
+${truncatedContent}
+\`\`\`
+
+`);
+            }
+          }
+          if (orchestratorContext.skills.length > 0) {
+            parts.push("### LOADED SKILLS (From Agent Frontmatter)\n\n");
+            for (const skill of orchestratorContext.skills) {
+              parts.push(`#### Skill: ${skill.name}
+`);
+              const truncatedContent = skill.content.length > 1e3 ? skill.content.substring(0, 1e3) + "\n... (truncated)" : skill.content;
+              parts.push(`\`\`\`markdown
+${truncatedContent}
+\`\`\`
+
+`);
+            }
+          }
+          if (orchestratorContext.requiresFragmentation && orchestratorContext.subtasks) {
+            parts.push("### SUBTASKS (Execute in Order)\n\n");
+            parts.push("**IMPORTANT**: Focus on the CURRENT subtask. Use `p. done` when complete to advance.\n\n");
+            parts.push("| # | Domain | Description | Status |\n");
+            parts.push("|---|--------|-------------|--------|\n");
+            for (const subtask of orchestratorContext.subtasks) {
+              const statusIcon = subtask.status === "in_progress" ? "\u25B6\uFE0F **CURRENT**" : subtask.status === "completed" ? "\u2705 Done" : subtask.status === "failed" ? "\u274C Failed" : "\u23F3 Pending";
+              parts.push(`| ${subtask.order} | ${subtask.domain} | ${subtask.description} | ${statusIcon} |
+`);
+            }
+            const currentSubtask = orchestratorContext.subtasks.find((s) => s.status === "in_progress");
+            if (currentSubtask) {
+              parts.push(`
+**FOCUS ON SUBTASK #${currentSubtask.order}**: ${currentSubtask.description}
+`);
+              parts.push(`Agent: ${currentSubtask.agent} | Domain: ${currentSubtask.domain}
+`);
+              if (currentSubtask.dependsOn.length > 0) {
+                parts.push(`Dependencies: ${currentSubtask.dependsOn.join(", ")}
+`);
+              }
+            }
+            parts.push("\n");
+          }
+        }
         const relevantState = this.filterRelevantState(state);
         if (relevantState) {
           parts.push("\n## PRJCT STATE (Project Management Data)\n");
@@ -8412,24 +8476,462 @@ When fragmenting tasks:
   }
 });
 
-// core/agentic/command-executor.ts
-import fs20 from "fs";
+// core/agentic/orchestrator-executor.ts
+import fs20 from "fs/promises";
 import path19 from "path";
 import os8 from "os";
+var DOMAIN_KEYWORDS, DOMAIN_DEPENDENCY_ORDER, OrchestratorExecutor, orchestratorExecutor, orchestrator_executor_default;
+var init_orchestrator_executor = __esm({
+  "core/agentic/orchestrator-executor.ts"() {
+    "use strict";
+    init_path_manager();
+    init_config_manager();
+    init_storage2();
+    init_fs();
+    init_template_loader();
+    DOMAIN_KEYWORDS = {
+      database: [
+        "database",
+        "db",
+        "sql",
+        "query",
+        "table",
+        "schema",
+        "migration",
+        "postgres",
+        "mysql",
+        "sqlite",
+        "mongo",
+        "redis",
+        "prisma",
+        "drizzle",
+        "orm",
+        "model",
+        "entity",
+        "repository",
+        "data layer",
+        "persist"
+      ],
+      backend: [
+        "api",
+        "endpoint",
+        "route",
+        "server",
+        "controller",
+        "service",
+        "middleware",
+        "auth",
+        "authentication",
+        "authorization",
+        "jwt",
+        "oauth",
+        "rest",
+        "graphql",
+        "trpc",
+        "express",
+        "fastify",
+        "hono",
+        "nest",
+        "validation",
+        "business logic"
+      ],
+      frontend: [
+        "ui",
+        "component",
+        "page",
+        "form",
+        "button",
+        "input",
+        "modal",
+        "dialog",
+        "react",
+        "vue",
+        "svelte",
+        "angular",
+        "next",
+        "nuxt",
+        "solid",
+        "css",
+        "style",
+        "tailwind",
+        "layout",
+        "responsive",
+        "animation",
+        "hook",
+        "state",
+        "context",
+        "redux",
+        "zustand",
+        "jotai"
+      ],
+      testing: [
+        "test",
+        "spec",
+        "unit",
+        "integration",
+        "e2e",
+        "jest",
+        "vitest",
+        "playwright",
+        "cypress",
+        "mocha",
+        "chai",
+        "mock",
+        "stub",
+        "fixture",
+        "coverage",
+        "assertion"
+      ],
+      devops: [
+        "docker",
+        "kubernetes",
+        "k8s",
+        "ci",
+        "cd",
+        "pipeline",
+        "deploy",
+        "github actions",
+        "vercel",
+        "aws",
+        "gcp",
+        "azure",
+        "terraform",
+        "nginx",
+        "caddy",
+        "env",
+        "environment",
+        "config",
+        "secret"
+      ],
+      uxui: [
+        "design",
+        "ux",
+        "user experience",
+        "accessibility",
+        "a11y",
+        "color",
+        "typography",
+        "spacing",
+        "prototype",
+        "wireframe",
+        "figma",
+        "user flow",
+        "interaction"
+      ]
+    };
+    DOMAIN_DEPENDENCY_ORDER = [
+      "database",
+      "backend",
+      "frontend",
+      "testing",
+      "devops"
+    ];
+    OrchestratorExecutor = class {
+      static {
+        __name(this, "OrchestratorExecutor");
+      }
+      /**
+       * Main entry point - executes full orchestration
+       *
+       * @param command - The command being executed (e.g., 'task')
+       * @param taskDescription - The task description from user
+       * @param projectPath - Path to the project
+       * @returns Full orchestrator context with loaded agents, skills, and subtasks
+       */
+      async execute(command, taskDescription, projectPath) {
+        const projectId = await config_manager_default.getProjectId(projectPath);
+        const globalPath = path_manager_default.getGlobalProjectPath(projectId);
+        const repoAnalysis = await this.loadRepoAnalysis(globalPath);
+        const { domains, primary } = await this.detectDomains(
+          taskDescription,
+          projectId,
+          repoAnalysis
+        );
+        const agents = await this.loadAgents(domains, projectId);
+        const skills = await this.loadSkills(agents);
+        const requiresFragmentation = this.shouldFragment(domains, taskDescription);
+        let subtasks = null;
+        if (requiresFragmentation && command === "task") {
+          subtasks = await this.createSubtasks(
+            taskDescription,
+            domains,
+            agents,
+            projectId
+          );
+        }
+        return {
+          detectedDomains: domains,
+          primaryDomain: primary,
+          agents,
+          skills,
+          requiresFragmentation,
+          subtasks,
+          project: {
+            id: projectId,
+            ecosystem: repoAnalysis?.ecosystem || "unknown",
+            conventions: repoAnalysis?.conventions || []
+          }
+        };
+      }
+      /**
+       * Load repo-analysis.json for project context
+       */
+      async loadRepoAnalysis(globalPath) {
+        try {
+          const analysisPath = path19.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs20.readFile(analysisPath, "utf-8");
+          return JSON.parse(content);
+        } catch (error) {
+          if (isNotFoundError(error)) return null;
+          console.warn("Failed to load repo-analysis.json:", error.message);
+          return null;
+        }
+      }
+      /**
+       * Detect which domains are relevant for this task
+       *
+       * Uses keyword matching + project context to determine domains.
+       * More intelligent than simple string matching - considers:
+       * - Task description keywords
+       * - Project technology stack
+       * - Available agents
+       */
+      async detectDomains(taskDescription, projectId, repoAnalysis) {
+        const taskLower = taskDescription.toLowerCase();
+        const detectedDomains = /* @__PURE__ */ new Map();
+        for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+          let score = 0;
+          for (const keyword of keywords) {
+            if (taskLower.includes(keyword.toLowerCase())) {
+              score += keyword.includes(" ") ? 3 : 1;
+            }
+          }
+          if (score > 0) {
+            detectedDomains.set(domain, score);
+          }
+        }
+        if (repoAnalysis?.technologies) {
+          const techStr = repoAnalysis.technologies.join(" ").toLowerCase();
+          if (/react|vue|svelte|angular|next|nuxt/.test(techStr)) {
+            const current = detectedDomains.get("frontend") || 0;
+            if (current > 0) detectedDomains.set("frontend", current + 2);
+          }
+          if (/express|fastify|hono|nest|koa/.test(techStr)) {
+            const current = detectedDomains.get("backend") || 0;
+            if (current > 0) detectedDomains.set("backend", current + 2);
+          }
+          if (/prisma|drizzle|mongoose|typeorm|sequelize/.test(techStr)) {
+            const current = detectedDomains.get("database") || 0;
+            if (current > 0) detectedDomains.set("database", current + 2);
+          }
+        }
+        const globalPath = path_manager_default.getGlobalProjectPath(projectId);
+        const availableAgents = await this.getAvailableAgentNames(globalPath);
+        const validDomains = Array.from(detectedDomains.entries()).filter(([domain]) => {
+          return availableAgents.some(
+            (agent) => agent === domain || agent.includes(domain) || domain.includes(agent.replace(".md", ""))
+          );
+        }).sort((a, b) => b[1] - a[1]).map(([domain]) => domain);
+        if (validDomains.length === 0) {
+          return { domains: ["general"], primary: "general" };
+        }
+        const primary = validDomains[0];
+        return { domains: validDomains, primary };
+      }
+      /**
+       * Get list of available agent file names
+       */
+      async getAvailableAgentNames(globalPath) {
+        try {
+          const agentsDir = path19.join(globalPath, "agents");
+          const files = await fs20.readdir(agentsDir);
+          return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Load agents for the detected domains
+       *
+       * Reads agent markdown files from {globalPath}/agents/
+       * and extracts their content and skills from frontmatter.
+       */
+      async loadAgents(domains, projectId) {
+        const globalPath = path_manager_default.getGlobalProjectPath(projectId);
+        const agentsDir = path19.join(globalPath, "agents");
+        const agents = [];
+        for (const domain of domains) {
+          const possibleNames = [
+            `${domain}.md`,
+            `${domain}-agent.md`,
+            `prjct-${domain}.md`
+          ];
+          for (const fileName of possibleNames) {
+            const filePath = path19.join(agentsDir, fileName);
+            try {
+              const content = await fs20.readFile(filePath, "utf-8");
+              const { frontmatter, body } = this.parseAgentFile(content);
+              agents.push({
+                name: fileName.replace(".md", ""),
+                domain,
+                content: body,
+                skills: frontmatter.skills || [],
+                filePath
+              });
+              break;
+            } catch {
+              continue;
+            }
+          }
+        }
+        return agents;
+      }
+      /**
+       * Parse agent markdown file to extract frontmatter and body
+       */
+      parseAgentFile(content) {
+        const parsed = parseFrontmatter(content);
+        const frontmatter = { ...parsed.frontmatter };
+        if (typeof frontmatter.skills === "string") {
+          frontmatter.skills = frontmatter.skills.split(",").map((s) => s.trim());
+        }
+        return {
+          frontmatter,
+          body: parsed.content
+        };
+      }
+      /**
+       * Load skills from agent frontmatter
+       *
+       * Skills are stored in ~/.claude/skills/{name}.md
+       */
+      async loadSkills(agents) {
+        const skillsDir = path19.join(os8.homedir(), ".claude", "skills");
+        const skills = [];
+        const loadedSkillNames = /* @__PURE__ */ new Set();
+        for (const agent of agents) {
+          for (const skillName of agent.skills) {
+            if (loadedSkillNames.has(skillName)) continue;
+            const skillPath = path19.join(skillsDir, `${skillName}.md`);
+            try {
+              const content = await fs20.readFile(skillPath, "utf-8");
+              skills.push({
+                name: skillName,
+                content,
+                filePath: skillPath
+              });
+              loadedSkillNames.add(skillName);
+            } catch {
+              console.warn(`Skill not found: ${skillName}`);
+            }
+          }
+        }
+        return skills;
+      }
+      /**
+       * Determine if task should be fragmented into subtasks
+       *
+       * Fragmentation is needed when:
+       * - 3+ domains are involved
+       * - Task explicitly mentions multiple areas
+       * - Task is complex (many keywords)
+       */
+      shouldFragment(domains, taskDescription) {
+        if (domains.length >= 3) return true;
+        const multiAreaIndicators = [
+          "full stack",
+          "fullstack",
+          "end to end",
+          "e2e",
+          "complete feature",
+          "from database to ui",
+          "across layers"
+        ];
+        const taskLower = taskDescription.toLowerCase();
+        for (const indicator of multiAreaIndicators) {
+          if (taskLower.includes(indicator)) return true;
+        }
+        const wordCount = taskDescription.split(/\s+/).length;
+        if (wordCount > 30 && domains.length >= 2) return true;
+        return false;
+      }
+      /**
+       * Create subtasks for a fragmented task
+       *
+       * Orders subtasks by domain dependency (database -> backend -> frontend)
+       * and stores them in state.json
+       */
+      async createSubtasks(taskDescription, domains, agents, projectId) {
+        const sortedDomains = [...domains].sort((a, b) => {
+          const orderA = DOMAIN_DEPENDENCY_ORDER.indexOf(a);
+          const orderB = DOMAIN_DEPENDENCY_ORDER.indexOf(b);
+          return (orderA === -1 ? 99 : orderA) - (orderB === -1 ? 99 : orderB);
+        });
+        const subtasks = sortedDomains.map((domain, index) => {
+          const agent = agents.find((a) => a.domain === domain);
+          const agentFile = agent ? `${agent.name}.md` : `${domain}.md`;
+          const dependsOn = sortedDomains.slice(0, index).map((d, i) => `subtask-${i + 1}`);
+          return {
+            id: `subtask-${index + 1}`,
+            description: this.generateSubtaskDescription(taskDescription, domain),
+            domain,
+            agent: agentFile,
+            status: index === 0 ? "in_progress" : "pending",
+            dependsOn,
+            order: index + 1
+          };
+        });
+        await stateStorage.createSubtasks(
+          projectId,
+          subtasks.map((st) => ({
+            id: st.id,
+            description: st.description,
+            domain: st.domain,
+            agent: st.agent,
+            dependsOn: st.dependsOn
+          }))
+        );
+        return subtasks;
+      }
+      /**
+       * Generate a domain-specific subtask description
+       */
+      generateSubtaskDescription(fullTask, domain) {
+        const domainDescriptions = {
+          database: "Set up data layer: schema, models, migrations",
+          backend: "Implement API: routes, controllers, services, validation",
+          frontend: "Build UI: components, forms, state management",
+          testing: "Write tests: unit, integration, e2e",
+          devops: "Configure deployment: CI/CD, environment, containers",
+          uxui: "Design user experience: flows, accessibility, styling"
+        };
+        const prefix = domainDescriptions[domain] || `Handle ${domain} aspects`;
+        return `[${domain.toUpperCase()}] ${prefix} for: ${fullTask.substring(0, 80)}${fullTask.length > 80 ? "..." : ""}`;
+      }
+    };
+    orchestratorExecutor = new OrchestratorExecutor();
+    orchestrator_executor_default = orchestratorExecutor;
+  }
+});
+
+// core/agentic/command-executor.ts
+import fs21 from "fs";
+import path20 from "path";
+import os9 from "os";
 function signalStart(commandName) {
   try {
-    const dir = path19.dirname(RUNNING_FILE);
-    if (!fs20.existsSync(dir)) {
-      fs20.mkdirSync(dir, { recursive: true });
+    const dir = path20.dirname(RUNNING_FILE);
+    if (!fs21.existsSync(dir)) {
+      fs21.mkdirSync(dir, { recursive: true });
     }
-    fs20.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
+    fs21.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
   } catch (_error) {
   }
 }
 function signalEnd() {
   try {
-    if (fs20.existsSync(RUNNING_FILE)) {
-      fs20.unlinkSync(RUNNING_FILE);
+    if (fs21.existsSync(RUNNING_FILE)) {
+      fs21.unlinkSync(RUNNING_FILE);
     }
   } catch (_error) {
   }
@@ -8448,7 +8950,8 @@ var init_command_executor = __esm({
     init_ground_truth();
     init_plan_mode();
     init_template_executor();
-    RUNNING_FILE = path19.join(os8.homedir(), ".prjct-cli", ".running");
+    init_orchestrator_executor();
+    RUNNING_FILE = path20.join(os9.homedir(), ".prjct-cli", ".running");
     __name(signalStart, "signalStart");
     __name(signalEnd, "signalEnd");
     CommandExecutor = class {
@@ -8528,6 +9031,24 @@ var init_command_executor = __esm({
             projectPath
           );
           const agenticInfo = template_executor_default.buildAgenticPrompt(agenticExecContext);
+          let orchestratorContext = null;
+          if (template_executor_default.requiresOrchestration(commandName) && taskDescription) {
+            try {
+              orchestratorContext = await orchestrator_executor_default.execute(
+                commandName,
+                taskDescription,
+                projectPath
+              );
+              console.log(`\u{1F3AF} Orchestrator:`);
+              console.log(`   \u2192 Domains: ${orchestratorContext.detectedDomains.join(", ")}`);
+              console.log(`   \u2192 Agents: ${orchestratorContext.agents.map((a) => a.name).join(", ") || "none loaded"}`);
+              if (orchestratorContext.requiresFragmentation && orchestratorContext.subtasks) {
+                console.log(`   \u2192 Subtasks: ${orchestratorContext.subtasks.length}`);
+              }
+            } catch (error) {
+              console.warn(`\u26A0\uFE0F  Orchestrator warning: ${error.message}`);
+            }
+          }
           const context = {
             ...metadataContext,
             agentsPath: agenticExecContext.paths.agentsDir,
@@ -8570,7 +9091,8 @@ var init_command_executor = __esm({
             learnedPatterns,
             null,
             relevantMemories,
-            planInfo
+            planInfo,
+            orchestratorContext
           );
           console.log(`\u{1F916} Template-first execution: Claude reads templates and decides`);
           if (agenticInfo.requiresOrchestration) {
@@ -8597,6 +9119,7 @@ var init_command_executor = __esm({
             groundTruth: groundTruthResult,
             learnedPatterns,
             relevantMemories,
+            orchestratorContext,
             memory: {
               create: /* @__PURE__ */ __name((memory) => memory_system_default.createMemory(metadataContext.projectId, memory), "create"),
               autoRemember: /* @__PURE__ */ __name((type, value, ctx) => memory_system_default.autoRemember(metadataContext.projectId, type, value, ctx), "autoRemember"),
@@ -8705,9 +9228,9 @@ var init_command_executor = __esm({
 
 // core/infrastructure/update-checker.ts
 import https from "https";
-import fs21 from "fs";
-import path20 from "path";
-import os9 from "os";
+import fs22 from "fs";
+import path21 from "path";
+import os10 from "os";
 import chalk from "chalk";
 var UpdateChecker, update_checker_default;
 var init_update_checker = __esm({
@@ -8723,8 +9246,8 @@ var init_update_checker = __esm({
       checkInterval;
       constructor() {
         this.packageName = "prjct-cli";
-        this.cacheDir = path20.join(os9.homedir(), ".prjct-cli", "config");
-        this.cacheFile = path20.join(this.cacheDir, "update-cache.json");
+        this.cacheDir = path21.join(os10.homedir(), ".prjct-cli", "config");
+        this.cacheFile = path21.join(this.cacheDir, "update-cache.json");
         this.checkInterval = 24 * 60 * 60 * 1e3;
       }
       /**
@@ -8732,8 +9255,8 @@ var init_update_checker = __esm({
        */
       getCurrentVersion() {
         try {
-          const packageJsonPath = path20.join(__dirname, "..", "..", "package.json");
-          const packageJson = JSON.parse(fs21.readFileSync(packageJsonPath, "utf8"));
+          const packageJsonPath = path21.join(__dirname, "..", "..", "package.json");
+          const packageJson = JSON.parse(fs22.readFileSync(packageJsonPath, "utf8"));
           return packageJson.version;
         } catch (error) {
           console.error("Error reading package version:", error.message);
@@ -8802,8 +9325,8 @@ var init_update_checker = __esm({
        */
       readCache() {
         try {
-          if (fs21.existsSync(this.cacheFile)) {
-            const cache2 = JSON.parse(fs21.readFileSync(this.cacheFile, "utf8"));
+          if (fs22.existsSync(this.cacheFile)) {
+            const cache2 = JSON.parse(fs22.readFileSync(this.cacheFile, "utf8"));
             return cache2;
           }
         } catch (_error) {
@@ -8815,10 +9338,10 @@ var init_update_checker = __esm({
        */
       writeCache(data) {
         try {
-          if (!fs21.existsSync(this.cacheDir)) {
-            fs21.mkdirSync(this.cacheDir, { recursive: true });
+          if (!fs22.existsSync(this.cacheDir)) {
+            fs22.mkdirSync(this.cacheDir, { recursive: true });
           }
-          fs21.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
+          fs22.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
         } catch (_error) {
         }
       }
@@ -8981,15 +9504,15 @@ var init_output = __esm({
 });
 
 // core/infrastructure/agent-detector.ts
-import fs22 from "fs";
-import path21 from "path";
+import fs23 from "fs";
+import path22 from "path";
 function isClaudeEnvironment() {
   if (process.env.CLAUDE_AGENT || process.env.ANTHROPIC_CLAUDE) return true;
   if (global.mcp || process.env.MCP_AVAILABLE) return true;
   const projectRoot = process.cwd();
-  if (fs22.existsSync(path21.join(projectRoot, "CLAUDE.md"))) return true;
+  if (fs23.existsSync(path22.join(projectRoot, "CLAUDE.md"))) return true;
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  if (fs22.existsSync(path21.join(homeDir, ".claude"))) return true;
+  if (fs23.existsSync(path22.join(homeDir, ".claude"))) return true;
   const cwd = process.cwd();
   if (cwd.includes("/.claude/") || cwd.includes("/claude-workspace/")) return true;
   return false;
@@ -9102,8 +9625,8 @@ var init_agent_detector = __esm({
 });
 
 // core/agentic/agent-router.ts
-import fs23 from "fs/promises";
-import path22 from "path";
+import fs24 from "fs/promises";
+import path23 from "path";
 var AgentRouter, agent_router_default;
 var init_agent_router = __esm({
   "core/agentic/agent-router.ts"() {
@@ -9132,12 +9655,12 @@ var init_agent_router = __esm({
       async loadAvailableAgents() {
         if (!this.agentsPath) return [];
         try {
-          const files = await fs23.readdir(this.agentsPath);
+          const files = await fs24.readdir(this.agentsPath);
           const agents = [];
           for (const file of files) {
             if (file.endsWith(".md")) {
               const name = file.replace(".md", "");
-              const content = await fs23.readFile(path22.join(this.agentsPath, file), "utf-8");
+              const content = await fs24.readFile(path23.join(this.agentsPath, file), "utf-8");
               agents.push({ name, content });
             }
           }
@@ -9162,8 +9685,8 @@ var init_agent_router = __esm({
       async loadAgent(name) {
         if (!this.agentsPath) return null;
         try {
-          const filePath = path22.join(this.agentsPath, `${name}.md`);
-          const content = await fs23.readFile(filePath, "utf-8");
+          const filePath = path23.join(this.agentsPath, `${name}.md`);
+          const content = await fs24.readFile(filePath, "utf-8");
           return { name, content };
         } catch (error) {
           if (!isNotFoundError(error)) {
@@ -9191,7 +9714,7 @@ var init_agent_router = __esm({
        */
       async logUsage(task, agent, _projectPath) {
         try {
-          const logPath = path22.join(
+          const logPath = path23.join(
             process.env.HOME || "",
             ".prjct-cli",
             "projects",
@@ -9204,7 +9727,7 @@ var init_agent_router = __esm({
             agent: typeof agent === "string" ? agent : agent.name,
             projectId: this.projectId
           }) + "\n";
-          await fs23.appendFile(logPath, entry);
+          await fs24.appendFile(logPath, entry);
         } catch (error) {
           if (!isNotFoundError(error)) {
             console.error(`Agent usage log error: ${error.message}`);
@@ -9359,8 +9882,8 @@ var init_agent_service = __esm({
 });
 
 // core/domain/analyzer.ts
-import fs24 from "fs/promises";
-import path23 from "path";
+import fs25 from "fs/promises";
+import path24 from "path";
 import { promisify as promisify3 } from "util";
 import { exec as execCallback2 } from "child_process";
 var exec3, CodebaseAnalyzer, analyzer, analyzer_default2;
@@ -9385,8 +9908,8 @@ var init_analyzer2 = __esm({
        */
       async readPackageJson() {
         try {
-          const packagePath = path23.join(this.projectPath, "package.json");
-          const content = await fs24.readFile(packagePath, "utf-8");
+          const packagePath = path24.join(this.projectPath, "package.json");
+          const content = await fs25.readFile(packagePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -9400,8 +9923,8 @@ var init_analyzer2 = __esm({
        */
       async readCargoToml() {
         try {
-          const cargoPath = path23.join(this.projectPath, "Cargo.toml");
-          return await fs24.readFile(cargoPath, "utf-8");
+          const cargoPath = path24.join(this.projectPath, "Cargo.toml");
+          return await fs25.readFile(cargoPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9414,8 +9937,8 @@ var init_analyzer2 = __esm({
        */
       async readRequirements() {
         try {
-          const reqPath = path23.join(this.projectPath, "requirements.txt");
-          return await fs24.readFile(reqPath, "utf-8");
+          const reqPath = path24.join(this.projectPath, "requirements.txt");
+          return await fs25.readFile(reqPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9428,8 +9951,8 @@ var init_analyzer2 = __esm({
        */
       async readGoMod() {
         try {
-          const goModPath = path23.join(this.projectPath, "go.mod");
-          return await fs24.readFile(goModPath, "utf-8");
+          const goModPath = path24.join(this.projectPath, "go.mod");
+          return await fs25.readFile(goModPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9442,8 +9965,8 @@ var init_analyzer2 = __esm({
        */
       async readGemfile() {
         try {
-          const gemfilePath = path23.join(this.projectPath, "Gemfile");
-          return await fs24.readFile(gemfilePath, "utf-8");
+          const gemfilePath = path24.join(this.projectPath, "Gemfile");
+          return await fs25.readFile(gemfilePath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9456,8 +9979,8 @@ var init_analyzer2 = __esm({
        */
       async readMixExs() {
         try {
-          const mixPath = path23.join(this.projectPath, "mix.exs");
-          return await fs24.readFile(mixPath, "utf-8");
+          const mixPath = path24.join(this.projectPath, "mix.exs");
+          return await fs25.readFile(mixPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9470,8 +9993,8 @@ var init_analyzer2 = __esm({
        */
       async readPomXml() {
         try {
-          const pomPath = path23.join(this.projectPath, "pom.xml");
-          return await fs24.readFile(pomPath, "utf-8");
+          const pomPath = path24.join(this.projectPath, "pom.xml");
+          return await fs25.readFile(pomPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9484,8 +10007,8 @@ var init_analyzer2 = __esm({
        */
       async readComposerJson() {
         try {
-          const composerPath = path23.join(this.projectPath, "composer.json");
-          const content = await fs24.readFile(composerPath, "utf-8");
+          const composerPath = path24.join(this.projectPath, "composer.json");
+          const content = await fs25.readFile(composerPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -9499,8 +10022,8 @@ var init_analyzer2 = __esm({
        */
       async readPyprojectToml() {
         try {
-          const pyprojectPath = path23.join(this.projectPath, "pyproject.toml");
-          return await fs24.readFile(pyprojectPath, "utf-8");
+          const pyprojectPath = path24.join(this.projectPath, "pyproject.toml");
+          return await fs25.readFile(pyprojectPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9536,7 +10059,7 @@ var init_analyzer2 = __esm({
        */
       async listConfigFiles() {
         try {
-          const entries = await fs24.readdir(this.projectPath);
+          const entries = await fs25.readdir(this.projectPath);
           const configPatterns = [
             /^package\.json$/,
             /^Cargo\.toml$/,
@@ -9566,7 +10089,7 @@ var init_analyzer2 = __esm({
        */
       async listDirectories() {
         try {
-          const entries = await fs24.readdir(this.projectPath, { withFileTypes: true });
+          const entries = await fs25.readdir(this.projectPath, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -9634,7 +10157,7 @@ var init_analyzer2 = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs24.access(path23.join(this.projectPath, filename));
+          await fs25.access(path24.join(this.projectPath, filename));
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -9648,8 +10171,8 @@ var init_analyzer2 = __esm({
        */
       async readFile(relativePath) {
         try {
-          const fullPath = path23.join(this.projectPath, relativePath);
-          return await fs24.readFile(fullPath, "utf-8");
+          const fullPath = path24.join(this.projectPath, relativePath);
+          return await fs25.readFile(fullPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -9678,15 +10201,15 @@ var init_analyzer2 = __esm({
 });
 
 // core/context/generator.ts
-import fs25 from "fs/promises";
-import path24 from "path";
+import fs26 from "fs/promises";
+import path25 from "path";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
 async function generateContext(projectId, repoPath) {
   const globalPath = path_manager_default.getGlobalProjectPath(projectId);
   const contextPath = path_manager_default.getContextPath(projectId);
   const storage = getStorage(projectId);
-  await fs25.mkdir(contextPath, { recursive: true });
+  await fs26.mkdir(contextPath, { recursive: true });
   const project = await storage.read(["project"]) || {};
   const taskPaths = await storage.list(["task"]);
   const featurePaths = await storage.list(["feature"]);
@@ -9752,8 +10275,8 @@ async function getPackageData(repoPath) {
     scripts: {}
   };
   try {
-    const pkgPath = path24.join(repoPath, "package.json");
-    const pkg = JSON.parse(await fs25.readFile(pkgPath, "utf-8"));
+    const pkgPath = path25.join(repoPath, "package.json");
+    const pkg = JSON.parse(await fs26.readFile(pkgPath, "utf-8"));
     data.dependencies = pkg.dependencies || {};
     data.devDependencies = pkg.devDependencies || {};
     data.scripts = pkg.scripts || {};
@@ -9762,7 +10285,7 @@ async function getPackageData(repoPath) {
   return data;
 }
 async function generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath) {
-  const projectName = project.name || path24.basename(repoPath);
+  const projectName = project.name || path25.basename(repoPath);
   const currentTask = tasks.find((t) => t.status === "in_progress");
   const pendingTasks = tasks.filter((t) => t.status === "pending");
   const activeFeatures = features.filter((f) => f.status === "in_progress" || f.status === "active");
@@ -9837,7 +10360,7 @@ ${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || "Specialis
     \u2514\u2500\u2500 pending.json
 \`\`\`
 `;
-  await fs25.writeFile(path24.join(contextPath, "CLAUDE.md"), content, "utf-8");
+  await fs26.writeFile(path25.join(contextPath, "CLAUDE.md"), content, "utf-8");
 }
 async function generateNowMd(contextPath, tasks) {
   const currentTask = tasks.find((t) => t.status === "in_progress");
@@ -9852,7 +10375,7 @@ async function generateNowMd(contextPath, tasks) {
 
 _No active task. Use /p:now to start._
 `;
-  await fs25.writeFile(path24.join(contextPath, "now.md"), content, "utf-8");
+  await fs26.writeFile(path25.join(contextPath, "now.md"), content, "utf-8");
 }
 async function generateQueueMd(contextPath, tasks) {
   const pendingTasks = tasks.filter((t) => t.status === "pending");
@@ -9860,7 +10383,7 @@ async function generateQueueMd(contextPath, tasks) {
 
 ${pendingTasks.length > 0 ? pendingTasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ""}`).join("\n") : "_Empty queue. Use /p:next to add tasks._"}
 `;
-  await fs25.writeFile(path24.join(contextPath, "queue.md"), content, "utf-8");
+  await fs26.writeFile(path25.join(contextPath, "queue.md"), content, "utf-8");
 }
 async function generateSummaryMd(contextPath, project, gitData, pkgData) {
   const content = `# PROJECT SUMMARY
@@ -9880,7 +10403,7 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 - Production: ${Object.keys(pkgData.dependencies).length}
 - Dev: ${Object.keys(pkgData.devDependencies).length}
 `;
-  await fs25.writeFile(path24.join(contextPath, "summary.md"), content, "utf-8");
+  await fs26.writeFile(path25.join(contextPath, "summary.md"), content, "utf-8");
 }
 var execAsync2;
 var init_generator = __esm({
@@ -9904,7 +10427,7 @@ var analysis_exports = {};
 __export(analysis_exports, {
   AnalysisCommands: () => AnalysisCommands
 });
-import path25 from "path";
+import path26 from "path";
 var AnalysisCommands;
 var init_analysis2 = __esm({
   "core/commands/analysis.ts"() {
@@ -9984,7 +10507,7 @@ var init_analysis2 = __esm({
         lines.push("# Repository Analysis\n");
         lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
 `);
-        const projectName = path25.basename(projectPath);
+        const projectName = path26.basename(projectPath);
         lines.push(`## Project: ${projectName}
 `);
         lines.push("## Stack Detected\n");
@@ -10108,7 +10631,7 @@ var planning_exports = {};
 __export(planning_exports, {
   PlanningCommands: () => PlanningCommands
 });
-import path26 from "path";
+import path27 from "path";
 async function getAnalysisCommands() {
   if (!_analysisCommands) {
     const { AnalysisCommands: AnalysisCommands2 } = await Promise.resolve().then(() => (init_analysis2(), analysis_exports));
@@ -10173,7 +10696,7 @@ var init_planning = __esm({
             }, null, 2)
           };
           for (const [filePath, content] of Object.entries(baseFiles)) {
-            await tool_registry_default.get("Write")(path26.join(globalPath, filePath), content);
+            await tool_registry_default.get("Write")(path27.join(globalPath, filePath), content);
           }
           const isEmpty = await this._detectEmptyDirectory(projectPath);
           const hasCode = await this._detectExistingCode(projectPath);
@@ -10194,7 +10717,7 @@ var init_planning = __esm({
               return { success: true, mode: "blank_no_idea", projectId };
             }
             output_default.spin("architect mode...");
-            const sessionPath = path26.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path27.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -10336,7 +10859,7 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!initResult.success) return initResult;
           console.log("\u{1F3D7}\uFE0F  Architect Mode - Code Generation\n");
           const globalPath = await this.getGlobalProjectPath(projectPath);
-          const planPath = path26.join(globalPath, "planning", "architect-session.md");
+          const planPath = path27.join(globalPath, "planning", "architect-session.md");
           let planContent;
           try {
             planContent = await file_helper_exports.readFile(planPath);
@@ -10410,7 +10933,7 @@ ${steps}`);
           if (isComplex) {
             output_default.spin("analyzing idea...");
             const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-            const sessionPath = path26.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path27.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -10465,10 +10988,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!featureName) {
             output_default.spin("loading specs...");
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
-            const specsPath2 = path26.join(globalPath2, "planning", "specs");
+            const specsPath2 = path27.join(globalPath2, "planning", "specs");
             try {
-              const fs27 = await import("fs/promises");
-              const files = await fs27.readdir(specsPath2);
+              const fs28 = await import("fs/promises");
+              const files = await fs28.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -10490,10 +11013,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           }
           output_default.spin("creating spec...");
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-          const specsPath = path26.join(globalPath, "planning", "specs");
+          const specsPath = path27.join(globalPath, "planning", "specs");
           await file_helper_exports.ensureDir(specsPath);
           const slug = featureName.toLowerCase().replace(/\s+/g, "-");
-          const specFile = path26.join(specsPath, `${slug}.md`);
+          const specFile = path27.join(specsPath, `${slug}.md`);
           const specContent = `# Specification: ${featureName}
 
 ## Overview
@@ -11133,18 +11656,18 @@ var init_workflow = __esm({
 });
 
 // core/utils/project-commands.ts
-import path27 from "path";
+import path28 from "path";
 async function detectPackageManager(projectPath, pkg) {
   const declared = pkg?.packageManager?.trim().toLowerCase();
   if (declared?.startsWith("pnpm@")) return "pnpm";
   if (declared?.startsWith("yarn@")) return "yarn";
   if (declared?.startsWith("bun@")) return "bun";
   if (declared?.startsWith("npm@")) return "npm";
-  if (await fileExists(path27.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path27.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists(path27.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists(path27.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists(path27.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(path28.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path28.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path28.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path28.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path28.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -11160,7 +11683,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path27.join(projectPath, "package.json");
+  const pkgPath = path28.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -11177,27 +11700,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path27.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path28.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path27.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path28.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path27.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path28.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path27.join(projectPath, "go.mod"))) {
+  if (await fileExists(path28.join(projectPath, "go.mod"))) {
     return { stack: "go", test: { tool: "go", command: "go test ./..." } };
   }
   const files = await listFiles(projectPath);
   if (files.some((f) => f.endsWith(".sln") || f.endsWith(".csproj") || f.endsWith(".fsproj"))) {
     return { stack: "dotnet", test: { tool: "dotnet", command: "dotnet test" } };
   }
-  if (await fileExists(path27.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path28.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path27.join(projectPath, "gradlew")) && (await fileExists(path27.join(projectPath, "build.gradle")) || await fileExists(path27.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path28.join(projectPath, "gradlew")) && (await fileExists(path28.join(projectPath, "build.gradle")) || await fileExists(path28.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -11214,7 +11737,7 @@ var init_project_commands = __esm({
 });
 
 // core/commands/shipping.ts
-import path28 from "path";
+import path29 from "path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -11343,7 +11866,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path28.join(projectPath, "package.json");
+          const pkgPath = path29.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);
@@ -11365,7 +11888,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path28.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path29.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())}
 
@@ -11761,7 +12284,7 @@ var init_registry = __esm({
 });
 
 // core/commands/analytics.ts
-import path29 from "path";
+import path30 from "path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -11786,7 +12309,7 @@ var init_analytics = __esm({
             output_default.fail("no project ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path29.basename(projectPath);
+          const projectName = path30.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -12024,7 +12547,7 @@ ${catInfo?.title || cat}:`);
 });
 
 // core/commands/cleanup.ts
-import path30 from "path";
+import path31 from "path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -12040,7 +12563,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path30.basename(filePath));
+          results.rotated.push(path31.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -12147,7 +12670,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path31 from "path";
+import path32 from "path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -12159,7 +12682,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 = path31.join(
+    const designsPath = path32.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -12199,7 +12722,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path31.join(designsPath, designFileName);
+    const designFilePath = path32.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -12223,7 +12746,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path32 from "path";
+import path33 from "path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -12275,7 +12798,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path32.join(
+    const snapshotsPath = path33.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
@@ -12296,7 +12819,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path32.join(snapshotsPath, "history.json");
+      const snapshotFile = path33.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -12336,11 +12859,11 @@ async function redo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path32.join(
+    const snapshotsPath = path33.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path32.join(snapshotsPath, "history.json");
+    const snapshotFile = path33.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -12399,11 +12922,11 @@ async function history(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path32.join(
+    const snapshotsPath = path33.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path32.join(snapshotsPath, "history.json");
+    const snapshotFile = path33.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -12509,8 +13032,8 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import path33 from "path";
-import fs26 from "fs";
+import path34 from "path";
+import fs27 from "fs";
 import chalk4 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -12620,7 +13143,7 @@ var init_setup2 = __esm({
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path33.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path34.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -12678,11 +13201,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs26.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs27.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs26.existsSync(settingsPath)) {
+          if (fs27.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs26.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs27.readFileSync(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -12690,7 +13213,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs26.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs27.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -13323,7 +13846,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.34.0",
+      version: "0.35.0",
       description: "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
       main: "core/index.ts",
       bin: {