prjct-cli 0.25.2 → 0.28.0

package/dist/bin/prjct.mjs

@@ -10,10 +10,10 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __glob = (map) => (path31) => {
-  var fn = map[path31];
+var __glob = (map) => (path32) => {
+  var fn = map[path32];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path31);
+  throw new Error("Module not found in bundle: " + path32);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -1567,6 +1567,7 @@ var init_command_installer = __esm({
           };
         }
         try {
+          await this.installRouter();
           await fs7.mkdir(this.claudeCommandsPath, { recursive: true });
           const commandFiles = await this.getCommandFiles();
           const installed = [];
@@ -1694,6 +1695,22 @@ var init_command_installer = __esm({
           return false;
         }
       }
+      /**
+       * Install the p.md router to ~/.claude/commands/
+       * This enables the "p. task" natural language trigger
+       * Claude Code bug #2422 prevents subdirectory slash command discovery
+       */
+      async installRouter() {
+        try {
+          const routerSource = path7.join(this.templatesDir, "p.md");
+          const routerDest = path7.join(this.homeDir, ".claude", "commands", "p.md");
+          const content = await fs7.readFile(routerSource, "utf-8");
+          await fs7.writeFile(routerDest, content, "utf-8");
+          return true;
+        } catch {
+          return false;
+        }
+      }
       /**
        * Sync commands - intelligent update that detects and removes orphans
        */
@@ -1709,6 +1726,7 @@ var init_command_installer = __esm({
           };
         }
         try {
+          await this.installRouter();
           await fs7.mkdir(this.claudeCommandsPath, { recursive: true });
           const templateFiles = await this.getCommandFiles();
           let installedFiles = [];
@@ -1777,6 +1795,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync } from "child_process";
+import fs8 from "fs";
+import path8 from "path";
+import os4 from "os";
 async function hasClaudeCodeCLI() {
   try {
     execSync("which claude", { stdio: "ignore" });
@@ -1829,11 +1850,190 @@ async function run() {
       results.configAction = configResult.action;
     }
     await command_installer_default.installDocs();
+    await installStatusLine();
+    await installSessionHook();
+    await installSkills();
   }
   await editors_config_default.saveConfig(VERSION, command_installer_default.getInstallPath());
+  await migrateProjectsCliVersion();
   showResults(results);
   return results;
 }
+async function migrateProjectsCliVersion() {
+  try {
+    const projectsDir = path8.join(os4.homedir(), ".prjct-cli", "projects");
+    if (!fs8.existsSync(projectsDir)) {
+      return;
+    }
+    const projectDirs = fs8.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    let migrated = 0;
+    for (const projectId of projectDirs) {
+      const projectJsonPath = path8.join(projectsDir, projectId, "project.json");
+      if (!fs8.existsSync(projectJsonPath)) {
+        continue;
+      }
+      try {
+        const content = fs8.readFileSync(projectJsonPath, "utf8");
+        const project = JSON.parse(content);
+        if (project.cliVersion !== VERSION) {
+          project.cliVersion = VERSION;
+          fs8.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          migrated++;
+        }
+      } catch {
+      }
+    }
+    if (migrated > 0) {
+      console.log(`   ${GREEN}\u2713${NC} Updated ${migrated} project(s) to v${VERSION}`);
+    }
+  } catch {
+  }
+}
+async function installStatusLine() {
+  try {
+    const claudeDir = path8.join(os4.homedir(), ".claude");
+    const settingsPath = path8.join(claudeDir, "settings.json");
+    const statusLinePath = path8.join(claudeDir, "prjct-statusline.sh");
+    if (!fs8.existsSync(claudeDir)) {
+      fs8.mkdirSync(claudeDir, { recursive: true });
+    }
+    const scriptContent = `#!/bin/bash
+# prjct Status Line for Claude Code
+# Shows version update notifications and current task
+
+# Current CLI version (embedded at install time)
+CLI_VERSION="${VERSION}"
+
+# Read JSON context from stdin (provided by Claude Code)
+read -r json
+
+# Extract cwd from JSON
+CWD=$(echo "$json" | grep -o '"cwd"[[:space:]]*:[[:space:]]*"[^"]*"' | sed 's/.*"cwd"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+# Check if this is a prjct project
+CONFIG="$CWD/.prjct/prjct.config.json"
+if [[ -f "$CONFIG" ]]; then
+  # Extract projectId
+  PROJECT_ID=$(grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' "$CONFIG" | sed 's/.*"projectId"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+  if [[ -n "$PROJECT_ID" ]]; then
+    PROJECT_JSON="$HOME/.prjct-cli/projects/$PROJECT_ID/project.json"
+
+    # Check version mismatch
+    if [[ -f "$PROJECT_JSON" ]]; then
+      PROJECT_VERSION=$(grep -o '"cliVersion"[[:space:]]*:[[:space:]]*"[^"]*"' "$PROJECT_JSON" | sed 's/.*"cliVersion"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+      # If no cliVersion or different version, show update notice
+      if [[ -z "$PROJECT_VERSION" ]] || [[ "$PROJECT_VERSION" != "$CLI_VERSION" ]]; then
+        echo "\u26A0\uFE0F prjct v$CLI_VERSION available! Run /p:sync"
+        exit 0
+      fi
+    else
+      # No project.json means project needs sync
+      echo "\u26A0\uFE0F prjct v$CLI_VERSION available! Run /p:sync"
+      exit 0
+    fi
+
+    # Show current task if exists
+    STATE="$HOME/.prjct-cli/projects/$PROJECT_ID/storage/state.json"
+    if [[ -f "$STATE" ]]; then
+      TASK=$(grep -o '"description"[[:space:]]*:[[:space:]]*"[^"]*"' "$STATE" | head -1 | sed 's/.*"description"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+      STATUS=$(grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' "$STATE" | head -1 | sed 's/.*"status"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+      if [[ -n "$TASK" ]] && [[ "$STATUS" == "active" ]]; then
+        # Truncate task to 40 chars
+        TASK_SHORT="\${TASK:0:40}"
+        [[ \${#TASK} -gt 40 ]] && TASK_SHORT="$TASK_SHORT..."
+        echo "\u{1F3AF} $TASK_SHORT"
+        exit 0
+      fi
+    fi
+  fi
+fi
+
+# Default: show prjct branding
+echo "\u26A1 prjct"
+`;
+    fs8.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+    let settings = {};
+    if (fs8.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs8.readFileSync(settingsPath, "utf8"));
+      } catch {
+      }
+    }
+    settings.statusLine = {
+      type: "command",
+      command: statusLinePath
+    };
+    fs8.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  } catch {
+  }
+}
+async function installSessionHook() {
+  try {
+    const claudeDir = path8.join(os4.homedir(), ".claude");
+    const hooksDir = path8.join(claudeDir, "hooks");
+    const hookPath = path8.join(hooksDir, "prjct-session-start.sh");
+    const settingsPath = path8.join(claudeDir, "settings.json");
+    if (!fs8.existsSync(hooksDir)) {
+      fs8.mkdirSync(hooksDir, { recursive: true });
+    }
+    const templateHookPath = path8.join(__dirname, "../../templates/hooks/prjct-session-start.sh");
+    if (fs8.existsSync(templateHookPath)) {
+      const hookContent = fs8.readFileSync(templateHookPath, "utf8");
+      fs8.writeFileSync(hookPath, hookContent, { mode: 493 });
+    }
+    let settings = {};
+    if (fs8.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs8.readFileSync(settingsPath, "utf8"));
+      } catch {
+      }
+    }
+    const hooks = settings.hooks || {};
+    hooks.SessionStart = [
+      {
+        matcher: "startup",
+        hooks: [
+          {
+            type: "command",
+            command: hookPath
+          }
+        ]
+      }
+    ];
+    settings.hooks = hooks;
+    fs8.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    console.log(`   ${GREEN}\u2713${NC} SessionStart hook installed`);
+  } catch {
+  }
+}
+async function installSkills() {
+  try {
+    const claudeDir = path8.join(os4.homedir(), ".claude");
+    const skillsDir = path8.join(claudeDir, "skills");
+    const templateSkillsDir = path8.join(__dirname, "../../templates/skills");
+    const skillNames = ["prjct-task", "prjct-sync", "prjct-done", "prjct-ship"];
+    let installed = 0;
+    for (const skillName of skillNames) {
+      const destDir = path8.join(skillsDir, skillName);
+      const templatePath = path8.join(templateSkillsDir, skillName, "SKILL.md");
+      if (fs8.existsSync(templatePath)) {
+        if (!fs8.existsSync(destDir)) {
+          fs8.mkdirSync(destDir, { recursive: true });
+        }
+        const skillContent = fs8.readFileSync(templatePath, "utf8");
+        fs8.writeFileSync(path8.join(destDir, "SKILL.md"), skillContent);
+        installed++;
+      }
+    }
+    if (installed > 0) {
+      console.log(`   ${GREEN}\u2713${NC} ${installed} Skills installed`);
+    }
+  } catch {
+  }
+}
 function showResults(results) {
   console.log("");
   if (results.claudeInstalled) {
@@ -1874,6 +2074,10 @@ var init_setup = __esm({
     __name(installClaudeCode, "installClaudeCode");
     __name(run, "run");
     setup_default = { run };
+    __name(migrateProjectsCliVersion, "migrateProjectsCliVersion");
+    __name(installStatusLine, "installStatusLine");
+    __name(installSessionHook, "installSessionHook");
+    __name(installSkills, "installSkills");
     __name(showResults, "showResults");
   }
 });
@@ -1979,6 +2183,8 @@ var init_project = __esm({
       repoPath: z3.string(),
       description: z3.string().optional(),
       version: z3.string().optional(),
+      cliVersion: z3.string().optional(),
+      // prjct-cli version used to sync
       techStack: z3.array(z3.string()),
       fileCount: z3.number(),
       commitCount: z3.number(),
@@ -2401,8 +2607,8 @@ var init_schemas2 = __esm({
 });
 
 // core/agentic/template-loader.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 function updateLruOrder(key) {
   const index = cacheOrder.indexOf(key);
   if (index > -1) cacheOrder.splice(index, 1);
@@ -2440,9 +2646,9 @@ async function load(commandName) {
     updateLruOrder(commandName);
     return cache.get(commandName);
   }
-  const templatePath = path8.join(TEMPLATES_DIR, `${commandName}.md`);
+  const templatePath = path9.join(TEMPLATES_DIR, `${commandName}.md`);
   try {
-    const rawContent = await fs8.readFile(templatePath, "utf-8");
+    const rawContent = await fs9.readFile(templatePath, "utf-8");
     const parsed = parseFrontmatter(rawContent);
     evictLru();
     cache.set(commandName, parsed);
@@ -2465,7 +2671,7 @@ var init_template_loader = __esm({
   "core/agentic/template-loader.ts"() {
     "use strict";
     init_errors();
-    TEMPLATES_DIR = path8.join(__dirname, "..", "..", "templates", "commands");
+    TEMPLATES_DIR = path9.join(__dirname, "..", "..", "templates", "commands");
     MAX_CACHE_SIZE = 50;
     cache = /* @__PURE__ */ new Map();
     cacheOrder = [];
@@ -2485,7 +2691,7 @@ var init_template_loader = __esm({
 });
 
 // core/agentic/context-builder.ts
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 var ContextBuilder, contextBuilder, context_builder_default;
 var init_context_builder = __esm({
   "core/agentic/context-builder.ts"() {
@@ -2563,7 +2769,7 @@ var init_context_builder = __esm({
         for (const [, filePath] of filteredEntries) {
           if (this._cache.has(filePath)) {
             try {
-              const stat = await fs9.stat(filePath);
+              const stat = await fs10.stat(filePath);
               const cachedMtime = this._mtimes.get(filePath);
               if (!cachedMtime || stat.mtimeMs > cachedMtime) {
                 this._cache.delete(filePath);
@@ -2586,7 +2792,7 @@ var init_context_builder = __esm({
         if (uncachedEntries.length > 0) {
           const readPromises = uncachedEntries.map(async ([key, filePath]) => {
             try {
-              const [content, stat] = await Promise.all([fs9.readFile(filePath, "utf-8"), fs9.stat(filePath)]);
+              const [content, stat] = await Promise.all([fs10.readFile(filePath, "utf-8"), fs10.stat(filePath)]);
               return { key, filePath, content, mtime: stat.mtimeMs };
             } catch {
               return { key, filePath, content: null, mtime: null };
@@ -2656,7 +2862,7 @@ var init_context_builder = __esm({
         if (uncachedPaths.length > 0) {
           const readPromises = uncachedPaths.map(async (filePath) => {
             try {
-              const content = await fs9.readFile(filePath, "utf-8");
+              const content = await fs10.readFile(filePath, "utf-8");
               return { filePath, content };
             } catch {
               return { filePath, content: null };
@@ -2687,7 +2893,7 @@ var init_context_builder = __esm({
        */
       async fileExists(filePath) {
         try {
-          await fs9.access(filePath);
+          await fs10.access(filePath);
           return true;
         } catch {
           return false;
@@ -2892,8 +3098,8 @@ var init_cache = __esm({
 });
 
 // core/storage/storage-manager.ts
-import fs10 from "fs/promises";
-import path9 from "path";
+import fs11 from "fs/promises";
+import path10 from "path";
 var StorageManager;
 var init_storage_manager = __esm({
   "core/storage/storage-manager.ts"() {
@@ -2936,7 +3142,7 @@ var init_storage_manager = __esm({
         }
         const filePath = this.getStoragePath(projectId);
         try {
-          const content = await fs10.readFile(filePath, "utf-8");
+          const content = await fs11.readFile(filePath, "utf-8");
           const data = JSON.parse(content);
           this.cache.set(projectId, data);
           return data;
@@ -2950,13 +3156,13 @@ var init_storage_manager = __esm({
       async write(projectId, data) {
         const storagePath = this.getStoragePath(projectId);
         const contextPath = this.getContextPath(projectId, this.getMdFilename());
-        await fs10.mkdir(path9.dirname(storagePath), { recursive: true });
-        await fs10.mkdir(path9.dirname(contextPath), { recursive: true });
+        await fs11.mkdir(path10.dirname(storagePath), { recursive: true });
+        await fs11.mkdir(path10.dirname(contextPath), { recursive: true });
         const tempPath = `${storagePath}.${Date.now()}.tmp`;
-        await fs10.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-        await fs10.rename(tempPath, storagePath);
+        await fs11.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+        await fs11.rename(tempPath, storagePath);
         const md2 = this.toMarkdown(data);
-        await fs10.writeFile(contextPath, md2, "utf-8");
+        await fs11.writeFile(contextPath, md2, "utf-8");
         this.cache.set(projectId, data);
       }
       /**
@@ -3004,7 +3210,7 @@ var init_storage_manager = __esm({
       async exists(projectId) {
         const filePath = this.getStoragePath(projectId);
         try {
-          await fs10.access(filePath);
+          await fs11.access(filePath);
           return true;
         } catch {
           return false;
@@ -4055,9 +4261,9 @@ var init_shipped_storage = __esm({
 });
 
 // core/storage/storage.ts
-import fs11 from "fs/promises";
-import path10 from "path";
-import os4 from "os";
+import fs12 from "fs/promises";
+import path11 from "path";
+import os5 from "os";
 function getStorage(projectId) {
   return new FileStorage(projectId);
 }
@@ -4074,7 +4280,7 @@ var init_storage = __esm({
       basePath;
       constructor(projectId) {
         this.projectId = projectId;
-        this.basePath = path10.join(os4.homedir(), ".prjct-cli/projects", projectId, "data");
+        this.basePath = path11.join(os5.homedir(), ".prjct-cli/projects", projectId, "data");
       }
       /**
        * Convert path array to file path
@@ -4083,17 +4289,17 @@ var init_storage = __esm({
        */
       pathToFile(pathArray) {
         if (pathArray.length === 1) {
-          return path10.join(this.basePath, `${pathArray[0]}.json`);
+          return path11.join(this.basePath, `${pathArray[0]}.json`);
         }
         const dir = pathArray[0] + "s";
         const rest = pathArray.slice(1);
         const filename = rest.join("/") + ".json";
-        return path10.join(this.basePath, dir, filename);
+        return path11.join(this.basePath, dir, filename);
       }
       async write(pathArray, data) {
         const filePath = this.pathToFile(pathArray);
-        await fs11.mkdir(path10.dirname(filePath), { recursive: true });
-        await fs11.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs12.mkdir(path11.dirname(filePath), { recursive: true });
+        await fs12.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
         eventBus.publish({
           type: inferEventType(pathArray, "write"),
           path: pathArray,
@@ -4108,16 +4314,16 @@ var init_storage = __esm({
       async read(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          const content = await fs11.readFile(filePath, "utf-8");
+          const content = await fs12.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
         }
       }
       async list(prefix) {
-        const dir = path10.join(this.basePath, prefix[0] + "s");
+        const dir = path11.join(this.basePath, prefix[0] + "s");
         try {
-          const files = await fs11.readdir(dir);
+          const files = await fs12.readdir(dir);
           return files.filter((f) => f.endsWith(".json") && f !== "index.json").map((f) => [...prefix, f.replace(".json", "")]);
         } catch {
           return [];
@@ -4126,7 +4332,7 @@ var init_storage = __esm({
       async delete(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs11.unlink(filePath);
+          await fs12.unlink(filePath);
           eventBus.publish({
             type: inferEventType(pathArray, "delete"),
             path: pathArray,
@@ -4143,7 +4349,7 @@ var init_storage = __esm({
       async exists(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs11.access(filePath);
+          await fs12.access(filePath);
           return true;
         } catch {
           return false;
@@ -4153,10 +4359,10 @@ var init_storage = __esm({
        * Update collection index
        */
       async updateIndex(collection, id, action) {
-        const indexPath = path10.join(this.basePath, collection + "s", "index.json");
+        const indexPath = path11.join(this.basePath, collection + "s", "index.json");
         let index = { ids: [], updatedAt: "" };
         try {
-          const content = await fs11.readFile(indexPath, "utf-8");
+          const content = await fs12.readFile(indexPath, "utf-8");
           index = JSON.parse(content);
         } catch {
         }
@@ -4166,8 +4372,8 @@ var init_storage = __esm({
           index.ids = index.ids.filter((i) => i !== id);
         }
         index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await fs11.mkdir(path10.dirname(indexPath), { recursive: true });
-        await fs11.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+        await fs12.mkdir(path11.dirname(indexPath), { recursive: true });
+        await fs12.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
       }
     };
     __name(getStorage, "getStorage");
@@ -4188,7 +4394,7 @@ var init_storage2 = __esm({
 });
 
 // core/outcomes/recorder.ts
-import path11 from "path";
+import path12 from "path";
 var OUTCOMES_DIR, OUTCOMES_FILE, OutcomeRecorder, outcomeRecorder, recorder_default;
 var init_recorder = __esm({
   "core/outcomes/recorder.ts"() {
@@ -4207,13 +4413,13 @@ var init_recorder = __esm({
        */
       getOutcomesDir(projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-        return path11.join(globalPath, OUTCOMES_DIR);
+        return path12.join(globalPath, OUTCOMES_DIR);
       }
       /**
        * Get outcomes file path for a project.
        */
       getOutcomesPath(projectId) {
-        return path11.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
+        return path12.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
       }
       /**
        * Record an outcome.
@@ -4224,7 +4430,7 @@ var init_recorder = __esm({
           id: generateUUID()
         };
         const outcomesPath = this.getOutcomesPath(projectId);
-        await ensureDir(path11.dirname(outcomesPath));
+        await ensureDir(path12.dirname(outcomesPath));
         await appendLine(outcomesPath, JSON.stringify(outcome));
         return outcome;
       }
@@ -4591,6 +4797,13 @@ var init_memory = __esm({
   }
 });
 
+// core/types/integrations.ts
+var init_integrations = __esm({
+  "core/types/integrations.ts"() {
+    "use strict";
+  }
+});
+
 // core/types/bus.ts
 var init_bus = __esm({
   "core/types/bus.ts"() {
@@ -4604,6 +4817,7 @@ var init_types = __esm({
     "use strict";
     init_fs();
     init_memory();
+    init_integrations();
     init_bus();
   }
 });
@@ -4619,8 +4833,8 @@ var init_outcomes2 = __esm({
 });
 
 // core/agentic/prompt-builder.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 var PromptBuilder, promptBuilder, prompt_builder_default;
 var init_prompt_builder = __esm({
   "core/agentic/prompt-builder.ts"() {
@@ -4654,14 +4868,14 @@ var init_prompt_builder = __esm({
        */
       loadChecklists() {
         if (this._checklistsCache) return this._checklistsCache;
-        const checklistsDir = path12.join(__dirname, "..", "..", "templates", "checklists");
+        const checklistsDir = path13.join(__dirname, "..", "..", "templates", "checklists");
         const checklists = {};
         try {
-          if (fs12.existsSync(checklistsDir)) {
-            const files = fs12.readdirSync(checklistsDir).filter((f) => f.endsWith(".md"));
+          if (fs13.existsSync(checklistsDir)) {
+            const files = fs13.readdirSync(checklistsDir).filter((f) => f.endsWith(".md"));
             for (const file of files) {
               const name = file.replace(".md", "");
-              const content = fs12.readFileSync(path12.join(checklistsDir, file), "utf-8");
+              const content = fs13.readFileSync(path13.join(checklistsDir, file), "utf-8");
               checklists[name] = content;
             }
           }
@@ -4762,10 +4976,10 @@ var init_prompt_builder = __esm({
        */
       loadChecklistRouting() {
         if (this._checklistRoutingCache) return this._checklistRoutingCache;
-        const routingPath = path12.join(__dirname, "..", "..", "templates", "agentic", "checklist-routing.md");
+        const routingPath = path13.join(__dirname, "..", "..", "templates", "agentic", "checklist-routing.md");
         try {
-          if (fs12.existsSync(routingPath)) {
-            this._checklistRoutingCache = fs12.readFileSync(routingPath, "utf-8");
+          if (fs13.existsSync(routingPath)) {
+            this._checklistRoutingCache = fs13.readFileSync(routingPath, "utf-8");
           }
         } catch {
         }
@@ -5023,7 +5237,7 @@ Context: ${fileCount} files available. Read what you need.
 });
 
 // core/agentic/tool-registry.ts
-import fs13 from "fs/promises";
+import fs14 from "fs/promises";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync, toolRegistry, tool_registry_default;
@@ -5068,14 +5282,14 @@ var init_tool_registry = __esm({
     };
     toolRegistry.register("Read", async (filePath) => {
       try {
-        return await fs13.readFile(filePath, "utf-8");
+        return await fs14.readFile(filePath, "utf-8");
       } catch {
         return null;
       }
     });
     toolRegistry.register("Write", async (filePath, content) => {
       try {
-        await fs13.writeFile(filePath, content, "utf-8");
+        await fs14.writeFile(filePath, content, "utf-8");
         return true;
       } catch {
         return false;
@@ -5546,10 +5760,10 @@ var init_chain_of_thought = __esm({
 });
 
 // core/utils/jsonl-helper.ts
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import fsSync from "fs";
 import readline from "readline";
-import path13 from "path";
+import path14 from "path";
 function parseJsonLines(content) {
   const lines = content.split("\n").filter((line) => line.trim());
   const entries = [];
@@ -5566,7 +5780,7 @@ function stringifyJsonLines(objects) {
 }
 async function readJsonLines(filePath) {
   try {
-    const content = await fs14.readFile(filePath, "utf-8");
+    const content = await fs15.readFile(filePath, "utf-8");
     return parseJsonLines(content);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -5577,15 +5791,15 @@ async function readJsonLines(filePath) {
 }
 async function writeJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs14.writeFile(filePath, content, "utf-8");
+  await fs15.writeFile(filePath, content, "utf-8");
 }
 async function appendJsonLine(filePath, object) {
   const line = JSON.stringify(object) + "\n";
-  await fs14.appendFile(filePath, line, "utf-8");
+  await fs15.appendFile(filePath, line, "utf-8");
 }
 async function appendJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs14.appendFile(filePath, content, "utf-8");
+  await fs15.appendFile(filePath, content, "utf-8");
 }
 async function filterJsonLines(filePath, predicate) {
   const entries = await readJsonLines(filePath);
@@ -5593,7 +5807,7 @@ async function filterJsonLines(filePath, predicate) {
 }
 async function countJsonLines(filePath) {
   try {
-    const content = await fs14.readFile(filePath, "utf-8");
+    const content = await fs15.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return lines.length;
   } catch (error) {
@@ -5652,7 +5866,7 @@ async function readJsonLinesStreaming(filePath, maxLines = 1e3) {
 }
 async function getFileSizeMB(filePath) {
   try {
-    const stats = await fs14.stat(filePath);
+    const stats = await fs15.stat(filePath);
     return stats.size / (1024 * 1024);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -5667,12 +5881,12 @@ async function rotateJsonLinesIfNeeded(filePath, maxSizeMB = 10) {
     return false;
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const dir = path13.dirname(filePath);
-  const ext = path13.extname(filePath);
-  const base = path13.basename(filePath, ext);
-  const archivePath = path13.join(dir, `${base}-${timestamp}${ext}`);
-  await fs14.rename(filePath, archivePath);
-  console.log(`\u{1F4E6} Rotated ${path13.basename(filePath)} (${sizeMB.toFixed(1)}MB) \u2192 ${path13.basename(archivePath)}`);
+  const dir = path14.dirname(filePath);
+  const ext = path14.extname(filePath);
+  const base = path14.basename(filePath, ext);
+  const archivePath = path14.join(dir, `${base}-${timestamp}${ext}`);
+  await fs15.rename(filePath, archivePath);
+  console.log(`\u{1F4E6} Rotated ${path14.basename(filePath)} (${sizeMB.toFixed(1)}MB) \u2192 ${path14.basename(archivePath)}`);
   return true;
 }
 async function appendJsonLineWithRotation(filePath, object, maxSizeMB = 10) {
@@ -5684,7 +5898,7 @@ async function checkFileSizeWarning(filePath, warnThresholdMB = 50) {
   const isLarge = sizeMB > warnThresholdMB;
   if (isLarge) {
     console.warn(
-      `\u26A0\uFE0F  Large file detected: ${path13.basename(filePath)} (${sizeMB.toFixed(1)}MB). Reading may use significant memory.`
+      `\u26A0\uFE0F  Large file detected: ${path14.basename(filePath)} (${sizeMB.toFixed(1)}MB). Reading may use significant memory.`
     );
   }
   return { sizeMB, isLarge };
@@ -5734,8 +5948,8 @@ var init_jsonl_helper = __esm({
 });
 
 // core/agentic/memory-system.ts
-import fs15 from "fs/promises";
-import path14 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 var CachedStore, SessionStore, HistoryStore, PatternStore, SemanticMemories, MemorySystem, memorySystem, memory_system_default;
 var init_memory_system = __esm({
   "core/agentic/memory-system.ts"() {
@@ -5765,12 +5979,12 @@ var init_memory_system = __esm({
        * Get full path for the store file
        */
       getPath(projectId) {
-        const basePath = path14.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
+        const basePath = path15.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
         const subdir = this.getSubdirectory();
         if (subdir) {
-          return path14.join(basePath, subdir, this.getFilename());
+          return path15.join(basePath, subdir, this.getFilename());
         }
-        return path14.join(basePath, this.getFilename());
+        return path15.join(basePath, this.getFilename());
       }
       /**
        * Load data from disk (with caching)
@@ -5782,7 +5996,7 @@ var init_memory_system = __esm({
         }
         const filePath = this.getPath(projectId);
         try {
-          const content = await fs15.readFile(filePath, "utf-8");
+          const content = await fs16.readFile(filePath, "utf-8");
           this._data = JSON.parse(content);
           this.afterLoad(this._data);
         } catch (error) {
@@ -5808,8 +6022,8 @@ var init_memory_system = __esm({
       async save(projectId) {
         if (!this._data) return;
         const filePath = this.getPath(projectId);
-        await fs15.mkdir(path14.dirname(filePath), { recursive: true });
-        await fs15.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
+        await fs16.mkdir(path15.dirname(filePath), { recursive: true });
+        await fs16.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
       }
       /**
        * Get cached data without loading (may be null)
@@ -5875,11 +6089,11 @@ var init_memory_system = __esm({
         const now = /* @__PURE__ */ new Date();
         const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
         const day = getTodayKey();
-        return path14.join(path_manager_default.getGlobalProjectPath(projectId), "memory", "sessions", yearMonth, `${day}.jsonl`);
+        return path15.join(path_manager_default.getGlobalProjectPath(projectId), "memory", "sessions", yearMonth, `${day}.jsonl`);
       }
       async appendHistory(projectId, entry) {
         const sessionPath = this._getSessionPath(projectId);
-        await ensureDir(path14.dirname(sessionPath));
+        await ensureDir(path15.dirname(sessionPath));
         const logEntry = {
           ts: getTimestamp(),
           ...entry,
@@ -6348,9 +6562,9 @@ Context: ${context}` : ""}`,
 });
 
 // core/agentic/ground-truth.ts
-import fs16 from "fs/promises";
-import path15 from "path";
-import os5 from "os";
+import fs17 from "fs/promises";
+import path16 from "path";
+import os6 from "os";
 import { execSync as execSync2 } from "child_process";
 function formatDuration2(ms) {
   const hours = Math.floor(ms / (1e3 * 60 * 60));
@@ -6387,7 +6601,7 @@ async function verifyDone(context) {
   const actual = {};
   const nowPath = context.paths.now;
   try {
-    const nowContent = await fs16.readFile(nowPath, "utf-8");
+    const nowContent = await fs17.readFile(nowPath, "utf-8");
     actual.nowExists = true;
     actual.nowContent = nowContent.trim();
     actual.nowLength = nowContent.length;
@@ -6411,7 +6625,7 @@ async function verifyDone(context) {
   }
   const nextPath = context.paths.next;
   try {
-    const nextContent = await fs16.readFile(nextPath, "utf-8");
+    const nextContent = await fs17.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[ \]/g) || [];
     actual.pendingTasks = tasks.length;
@@ -6421,7 +6635,7 @@ async function verifyDone(context) {
   }
   const metricsPath = context.paths.metrics;
   try {
-    await fs16.access(path15.dirname(metricsPath), fs16.constants.W_OK);
+    await fs17.access(path16.dirname(metricsPath), fs17.constants.W_OK);
     actual.metricsWritable = true;
   } catch {
     actual.metricsWritable = false;
@@ -6452,9 +6666,9 @@ async function verifyShip(context) {
   } catch {
     actual.gitAvailable = false;
   }
-  const pkgPath = path15.join(context.projectPath, "package.json");
+  const pkgPath = path16.join(context.projectPath, "package.json");
   try {
-    const pkgContent = await fs16.readFile(pkgPath, "utf-8");
+    const pkgContent = await fs17.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     actual.currentVersion = pkg.version;
     actual.hasPackageJson = true;
@@ -6463,7 +6677,7 @@ async function verifyShip(context) {
   }
   const shippedPath = context.paths.shipped;
   try {
-    const shippedContent = await fs16.readFile(shippedPath, "utf-8");
+    const shippedContent = await fs17.readFile(shippedPath, "utf-8");
     actual.shippedExists = true;
     const featureName = context.params.feature || context.params.description;
     if (featureName) {
@@ -6479,7 +6693,7 @@ async function verifyShip(context) {
   }
   if (actual.hasPackageJson) {
     try {
-      const pkgContent = await fs16.readFile(pkgPath, "utf-8");
+      const pkgContent = await fs17.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       actual.hasTestScript = !!pkg.scripts?.test;
     } catch {
@@ -6499,7 +6713,7 @@ async function verifyFeature(context) {
   const actual = {};
   const nextPath = context.paths.next;
   try {
-    const nextContent = await fs16.readFile(nextPath, "utf-8");
+    const nextContent = await fs17.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[[ x]\]/g) || [];
     actual.taskCount = tasks.length;
@@ -6514,7 +6728,7 @@ async function verifyFeature(context) {
   }
   const roadmapPath = context.paths.roadmap;
   try {
-    const roadmapContent = await fs16.readFile(roadmapPath, "utf-8");
+    const roadmapContent = await fs17.readFile(roadmapPath, "utf-8");
     actual.roadmapExists = true;
     const featureName = context.params.description || context.params.feature;
     if (featureName) {
@@ -6529,7 +6743,7 @@ async function verifyFeature(context) {
   }
   const nowPath = context.paths.now;
   try {
-    const nowContent = await fs16.readFile(nowPath, "utf-8");
+    const nowContent = await fs17.readFile(nowPath, "utf-8");
     actual.hasActiveTask = nowContent.trim().length > 0 && !nowContent.includes("No current task");
     if (actual.hasActiveTask) {
       recommendations.push("Consider completing current task first with /p:done");
@@ -6550,7 +6764,7 @@ async function verifyNow(context) {
   const actual = {};
   const nowPath = context.paths.now;
   try {
-    const nowContent = await fs16.readFile(nowPath, "utf-8");
+    const nowContent = await fs17.readFile(nowPath, "utf-8");
     actual.nowExists = true;
     actual.nowContent = nowContent.trim();
     const hasRealTask = nowContent.trim().length > 0 && !nowContent.includes("No current task") && !nowContent.match(/^#\s*NOW\s*$/m);
@@ -6566,7 +6780,7 @@ async function verifyNow(context) {
   }
   const nextPath = context.paths.next;
   try {
-    const nextContent = await fs16.readFile(nextPath, "utf-8");
+    const nextContent = await fs17.readFile(nextPath, "utf-8");
     const pendingTasks = (nextContent.match(/- \[ \]/g) || []).length;
     actual.pendingTasks = pendingTasks;
     if (!context.params.task && pendingTasks > 0) {
@@ -6586,9 +6800,9 @@ async function verifyInit(context) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path15.join(context.projectPath, ".prjct/prjct.config.json");
+  const configPath = path16.join(context.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs16.readFile(configPath, "utf-8");
+    const configContent = await fs17.readFile(configPath, "utf-8");
     actual.alreadyInitialized = true;
     actual.existingConfig = JSON.parse(configContent);
     warnings.push("Project already initialized");
@@ -6596,13 +6810,13 @@ async function verifyInit(context) {
   } catch {
     actual.alreadyInitialized = false;
   }
-  const globalPath = path15.join(os5.homedir(), ".prjct-cli");
+  const globalPath = path16.join(os6.homedir(), ".prjct-cli");
   try {
-    await fs16.access(globalPath, fs16.constants.W_OK);
+    await fs17.access(globalPath, fs17.constants.W_OK);
     actual.globalPathWritable = true;
   } catch {
     try {
-      await fs16.mkdir(globalPath, { recursive: true });
+      await fs17.mkdir(globalPath, { recursive: true });
       actual.globalPathWritable = true;
       actual.globalPathCreated = true;
     } catch {
@@ -6622,9 +6836,9 @@ async function verifySync(context) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path15.join(context.projectPath, ".prjct/prjct.config.json");
+  const configPath = path16.join(context.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs16.readFile(configPath, "utf-8");
+    const configContent = await fs17.readFile(configPath, "utf-8");
     actual.hasConfig = true;
     actual.config = JSON.parse(configContent);
   } catch {
@@ -6634,9 +6848,9 @@ async function verifySync(context) {
     return { verified: false, actual, warnings, recommendations };
   }
   const projectId = actual.config?.projectId;
-  const globalProjectPath = path15.join(os5.homedir(), ".prjct-cli/projects", projectId || "");
+  const globalProjectPath = path16.join(os6.homedir(), ".prjct-cli/projects", projectId || "");
   try {
-    await fs16.access(globalProjectPath);
+    await fs17.access(globalProjectPath);
     actual.globalStorageExists = true;
   } catch {
     actual.globalStorageExists = false;
@@ -6658,7 +6872,7 @@ async function verifyAnalyze(context) {
   actual.detectedFiles = [];
   for (const file of files) {
     try {
-      await fs16.access(path15.join(context.projectPath, file));
+      await fs17.access(path16.join(context.projectPath, file));
       actual.detectedFiles.push(file);
     } catch {
     }
@@ -6671,7 +6885,7 @@ async function verifyAnalyze(context) {
   actual.detectedSrcDirs = [];
   for (const dir of srcDirs) {
     try {
-      const stat = await fs16.stat(path15.join(context.projectPath, dir));
+      const stat = await fs17.stat(path16.join(context.projectPath, dir));
       if (stat.isDirectory()) {
         ;
         actual.detectedSrcDirs.push(dir);
@@ -6693,9 +6907,9 @@ async function verifySpec(context) {
   const actual = {};
   const specsPath = context.paths.specs;
   try {
-    await fs16.access(specsPath);
+    await fs17.access(specsPath);
     actual.specsExists = true;
-    const files = await fs16.readdir(specsPath);
+    const files = await fs17.readdir(specsPath);
     actual.existingSpecs = files.filter((f) => f.endsWith(".md"));
     actual.specCount = actual.existingSpecs.length;
   } catch {
@@ -7227,23 +7441,23 @@ var init_plan_mode = __esm({
 });
 
 // core/agentic/command-executor.ts
-import fs17 from "fs";
-import path16 from "path";
-import os6 from "os";
+import fs18 from "fs";
+import path17 from "path";
+import os7 from "os";
 function signalStart(commandName) {
   try {
-    const dir = path16.dirname(RUNNING_FILE);
-    if (!fs17.existsSync(dir)) {
-      fs17.mkdirSync(dir, { recursive: true });
+    const dir = path17.dirname(RUNNING_FILE);
+    if (!fs18.existsSync(dir)) {
+      fs18.mkdirSync(dir, { recursive: true });
     }
-    fs17.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
+    fs18.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
   } catch {
   }
 }
 function signalEnd() {
   try {
-    if (fs17.existsSync(RUNNING_FILE)) {
-      fs17.unlinkSync(RUNNING_FILE);
+    if (fs18.existsSync(RUNNING_FILE)) {
+      fs18.unlinkSync(RUNNING_FILE);
     }
   } catch {
   }
@@ -7261,7 +7475,7 @@ var init_command_executor = __esm({
     init_memory_system();
     init_ground_truth();
     init_plan_mode();
-    RUNNING_FILE = path16.join(os6.homedir(), ".prjct-cli", ".running");
+    RUNNING_FILE = path17.join(os7.homedir(), ".prjct-cli", ".running");
     __name(signalStart, "signalStart");
     __name(signalEnd, "signalEnd");
     CommandExecutor = class {
@@ -7337,8 +7551,8 @@ var init_command_executor = __esm({
           let context = metadataContext;
           context = {
             ...context,
-            agentsPath: path16.join(os6.homedir(), ".prjct-cli", "projects", metadataContext.projectId || "", "agents"),
-            agentRoutingPath: path16.join(__dirname, "..", "..", "templates", "agentic", "agent-routing.md"),
+            agentsPath: path17.join(os7.homedir(), ".prjct-cli", "projects", metadataContext.projectId || "", "agents"),
+            agentRoutingPath: path17.join(__dirname, "..", "..", "templates", "agentic", "agent-routing.md"),
             agenticDelegation: true
           };
           const state = await context_builder_default.loadState(metadataContext);
@@ -7500,9 +7714,9 @@ var init_command_executor = __esm({
 
 // core/infrastructure/update-checker.ts
 import https from "https";
-import fs18 from "fs";
-import path17 from "path";
-import os7 from "os";
+import fs19 from "fs";
+import path18 from "path";
+import os8 from "os";
 import chalk from "chalk";
 var UpdateChecker, update_checker_default;
 var init_update_checker = __esm({
@@ -7518,8 +7732,8 @@ var init_update_checker = __esm({
       checkInterval;
       constructor() {
         this.packageName = "prjct-cli";
-        this.cacheDir = path17.join(os7.homedir(), ".prjct-cli", "config");
-        this.cacheFile = path17.join(this.cacheDir, "update-cache.json");
+        this.cacheDir = path18.join(os8.homedir(), ".prjct-cli", "config");
+        this.cacheFile = path18.join(this.cacheDir, "update-cache.json");
         this.checkInterval = 24 * 60 * 60 * 1e3;
       }
       /**
@@ -7527,8 +7741,8 @@ var init_update_checker = __esm({
        */
       getCurrentVersion() {
         try {
-          const packageJsonPath = path17.join(__dirname, "..", "..", "package.json");
-          const packageJson = JSON.parse(fs18.readFileSync(packageJsonPath, "utf8"));
+          const packageJsonPath = path18.join(__dirname, "..", "..", "package.json");
+          const packageJson = JSON.parse(fs19.readFileSync(packageJsonPath, "utf8"));
           return packageJson.version;
         } catch (error) {
           console.error("Error reading package version:", error.message);
@@ -7597,8 +7811,8 @@ var init_update_checker = __esm({
        */
       readCache() {
         try {
-          if (fs18.existsSync(this.cacheFile)) {
-            const cache2 = JSON.parse(fs18.readFileSync(this.cacheFile, "utf8"));
+          if (fs19.existsSync(this.cacheFile)) {
+            const cache2 = JSON.parse(fs19.readFileSync(this.cacheFile, "utf8"));
             return cache2;
           }
         } catch {
@@ -7610,10 +7824,10 @@ var init_update_checker = __esm({
        */
       writeCache(data) {
         try {
-          if (!fs18.existsSync(this.cacheDir)) {
-            fs18.mkdirSync(this.cacheDir, { recursive: true });
+          if (!fs19.existsSync(this.cacheDir)) {
+            fs19.mkdirSync(this.cacheDir, { recursive: true });
           }
-          fs18.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
+          fs19.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
         } catch {
         }
       }
@@ -7776,15 +7990,15 @@ var init_output = __esm({
 });
 
 // core/infrastructure/agent-detector.ts
-import fs19 from "fs";
-import path18 from "path";
+import fs20 from "fs";
+import path19 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 (fs19.existsSync(path18.join(projectRoot, "CLAUDE.md"))) return true;
+  if (fs20.existsSync(path19.join(projectRoot, "CLAUDE.md"))) return true;
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  if (fs19.existsSync(path18.join(homeDir, ".claude"))) return true;
+  if (fs20.existsSync(path19.join(homeDir, ".claude"))) return true;
   const cwd = process.cwd();
   if (cwd.includes("/.claude/") || cwd.includes("/claude-workspace/")) return true;
   return false;
@@ -7897,8 +8111,8 @@ var init_agent_detector = __esm({
 });
 
 // core/agentic/agent-router.ts
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs21 from "fs/promises";
+import path20 from "path";
 var AgentRouter, agent_router_default;
 var init_agent_router = __esm({
   "core/agentic/agent-router.ts"() {
@@ -7926,12 +8140,12 @@ var init_agent_router = __esm({
       async loadAvailableAgents() {
         if (!this.agentsPath) return [];
         try {
-          const files = await fs20.readdir(this.agentsPath);
+          const files = await fs21.readdir(this.agentsPath);
           const agents = [];
           for (const file of files) {
             if (file.endsWith(".md")) {
               const name = file.replace(".md", "");
-              const content = await fs20.readFile(path19.join(this.agentsPath, file), "utf-8");
+              const content = await fs21.readFile(path20.join(this.agentsPath, file), "utf-8");
               agents.push({ name, content });
             }
           }
@@ -7953,8 +8167,8 @@ var init_agent_router = __esm({
       async loadAgent(name) {
         if (!this.agentsPath) return null;
         try {
-          const filePath = path19.join(this.agentsPath, `${name}.md`);
-          const content = await fs20.readFile(filePath, "utf-8");
+          const filePath = path20.join(this.agentsPath, `${name}.md`);
+          const content = await fs21.readFile(filePath, "utf-8");
           return { name, content };
         } catch {
           return null;
@@ -7979,7 +8193,7 @@ var init_agent_router = __esm({
        */
       async logUsage(task, agent, _projectPath) {
         try {
-          const logPath = path19.join(
+          const logPath = path20.join(
             process.env.HOME || "",
             ".prjct-cli",
             "projects",
@@ -7992,7 +8206,7 @@ var init_agent_router = __esm({
             agent: typeof agent === "string" ? agent : agent.name,
             projectId: this.projectId
           }) + "\n";
-          await fs20.appendFile(logPath, entry);
+          await fs21.appendFile(logPath, entry);
         } catch {
         }
       }
@@ -8143,8 +8357,8 @@ var init_agent_service = __esm({
 });
 
 // core/domain/analyzer.ts
-import fs21 from "fs/promises";
-import path20 from "path";
+import fs22 from "fs/promises";
+import path21 from "path";
 import { promisify as promisify3 } from "util";
 import { exec as execCallback2 } from "child_process";
 var exec3, CodebaseAnalyzer, analyzer, analyzer_default2;
@@ -8168,8 +8382,8 @@ var init_analyzer2 = __esm({
        */
       async readPackageJson() {
         try {
-          const packagePath = path20.join(this.projectPath, "package.json");
-          const content = await fs21.readFile(packagePath, "utf-8");
+          const packagePath = path21.join(this.projectPath, "package.json");
+          const content = await fs22.readFile(packagePath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -8180,8 +8394,8 @@ var init_analyzer2 = __esm({
        */
       async readCargoToml() {
         try {
-          const cargoPath = path20.join(this.projectPath, "Cargo.toml");
-          return await fs21.readFile(cargoPath, "utf-8");
+          const cargoPath = path21.join(this.projectPath, "Cargo.toml");
+          return await fs22.readFile(cargoPath, "utf-8");
         } catch {
           return null;
         }
@@ -8191,8 +8405,8 @@ var init_analyzer2 = __esm({
        */
       async readRequirements() {
         try {
-          const reqPath = path20.join(this.projectPath, "requirements.txt");
-          return await fs21.readFile(reqPath, "utf-8");
+          const reqPath = path21.join(this.projectPath, "requirements.txt");
+          return await fs22.readFile(reqPath, "utf-8");
         } catch {
           return null;
         }
@@ -8202,8 +8416,8 @@ var init_analyzer2 = __esm({
        */
       async readGoMod() {
         try {
-          const goModPath = path20.join(this.projectPath, "go.mod");
-          return await fs21.readFile(goModPath, "utf-8");
+          const goModPath = path21.join(this.projectPath, "go.mod");
+          return await fs22.readFile(goModPath, "utf-8");
         } catch {
           return null;
         }
@@ -8213,8 +8427,8 @@ var init_analyzer2 = __esm({
        */
       async readGemfile() {
         try {
-          const gemfilePath = path20.join(this.projectPath, "Gemfile");
-          return await fs21.readFile(gemfilePath, "utf-8");
+          const gemfilePath = path21.join(this.projectPath, "Gemfile");
+          return await fs22.readFile(gemfilePath, "utf-8");
         } catch {
           return null;
         }
@@ -8224,8 +8438,8 @@ var init_analyzer2 = __esm({
        */
       async readMixExs() {
         try {
-          const mixPath = path20.join(this.projectPath, "mix.exs");
-          return await fs21.readFile(mixPath, "utf-8");
+          const mixPath = path21.join(this.projectPath, "mix.exs");
+          return await fs22.readFile(mixPath, "utf-8");
         } catch {
           return null;
         }
@@ -8235,8 +8449,8 @@ var init_analyzer2 = __esm({
        */
       async readPomXml() {
         try {
-          const pomPath = path20.join(this.projectPath, "pom.xml");
-          return await fs21.readFile(pomPath, "utf-8");
+          const pomPath = path21.join(this.projectPath, "pom.xml");
+          return await fs22.readFile(pomPath, "utf-8");
         } catch {
           return null;
         }
@@ -8246,8 +8460,8 @@ var init_analyzer2 = __esm({
        */
       async readComposerJson() {
         try {
-          const composerPath = path20.join(this.projectPath, "composer.json");
-          const content = await fs21.readFile(composerPath, "utf-8");
+          const composerPath = path21.join(this.projectPath, "composer.json");
+          const content = await fs22.readFile(composerPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -8258,8 +8472,8 @@ var init_analyzer2 = __esm({
        */
       async readPyprojectToml() {
         try {
-          const pyprojectPath = path20.join(this.projectPath, "pyproject.toml");
-          return await fs21.readFile(pyprojectPath, "utf-8");
+          const pyprojectPath = path21.join(this.projectPath, "pyproject.toml");
+          return await fs22.readFile(pyprojectPath, "utf-8");
         } catch {
           return null;
         }
@@ -8292,7 +8506,7 @@ var init_analyzer2 = __esm({
        */
       async listConfigFiles() {
         try {
-          const entries = await fs21.readdir(this.projectPath);
+          const entries = await fs22.readdir(this.projectPath);
           const configPatterns = [
             /^package\.json$/,
             /^Cargo\.toml$/,
@@ -8319,7 +8533,7 @@ var init_analyzer2 = __esm({
        */
       async listDirectories() {
         try {
-          const entries = await fs21.readdir(this.projectPath, { withFileTypes: true });
+          const entries = await fs22.readdir(this.projectPath, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
         } catch {
           return [];
@@ -8384,7 +8598,7 @@ var init_analyzer2 = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs21.access(path20.join(this.projectPath, filename));
+          await fs22.access(path21.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -8395,8 +8609,8 @@ var init_analyzer2 = __esm({
        */
       async readFile(relativePath) {
         try {
-          const fullPath = path20.join(this.projectPath, relativePath);
-          return await fs21.readFile(fullPath, "utf-8");
+          const fullPath = path21.join(this.projectPath, relativePath);
+          return await fs22.readFile(fullPath, "utf-8");
         } catch {
           return null;
         }
@@ -8422,16 +8636,16 @@ var init_analyzer2 = __esm({
 });
 
 // core/context/generator.ts
-import fs22 from "fs/promises";
-import path21 from "path";
-import os8 from "os";
+import fs23 from "fs/promises";
+import path22 from "path";
+import os9 from "os";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
 async function generateContext(projectId, repoPath) {
-  const globalPath = path21.join(os8.homedir(), ".prjct-cli/projects", projectId);
-  const contextPath = path21.join(globalPath, "context");
+  const globalPath = path22.join(os9.homedir(), ".prjct-cli/projects", projectId);
+  const contextPath = path22.join(globalPath, "context");
   const storage = getStorage(projectId);
-  await fs22.mkdir(contextPath, { recursive: true });
+  await fs23.mkdir(contextPath, { recursive: true });
   const project = await storage.read(["project"]) || {};
   const taskPaths = await storage.list(["task"]);
   const featurePaths = await storage.list(["feature"]);
@@ -8497,8 +8711,8 @@ async function getPackageData(repoPath) {
     scripts: {}
   };
   try {
-    const pkgPath = path21.join(repoPath, "package.json");
-    const pkg = JSON.parse(await fs22.readFile(pkgPath, "utf-8"));
+    const pkgPath = path22.join(repoPath, "package.json");
+    const pkg = JSON.parse(await fs23.readFile(pkgPath, "utf-8"));
     data.dependencies = pkg.dependencies || {};
     data.devDependencies = pkg.devDependencies || {};
     data.scripts = pkg.scripts || {};
@@ -8507,7 +8721,7 @@ async function getPackageData(repoPath) {
   return data;
 }
 async function generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath) {
-  const projectName = project.name || path21.basename(repoPath);
+  const projectName = project.name || path22.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");
@@ -8582,7 +8796,7 @@ ${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || "Specialis
     \u2514\u2500\u2500 pending.json
 \`\`\`
 `;
-  await fs22.writeFile(path21.join(contextPath, "CLAUDE.md"), content, "utf-8");
+  await fs23.writeFile(path22.join(contextPath, "CLAUDE.md"), content, "utf-8");
 }
 async function generateNowMd(contextPath, tasks) {
   const currentTask = tasks.find((t) => t.status === "in_progress");
@@ -8597,7 +8811,7 @@ async function generateNowMd(contextPath, tasks) {
 
 _No active task. Use /p:now to start._
 `;
-  await fs22.writeFile(path21.join(contextPath, "now.md"), content, "utf-8");
+  await fs23.writeFile(path22.join(contextPath, "now.md"), content, "utf-8");
 }
 async function generateQueueMd(contextPath, tasks) {
   const pendingTasks = tasks.filter((t) => t.status === "pending");
@@ -8605,7 +8819,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 fs22.writeFile(path21.join(contextPath, "queue.md"), content, "utf-8");
+  await fs23.writeFile(path22.join(contextPath, "queue.md"), content, "utf-8");
 }
 async function generateSummaryMd(contextPath, project, gitData, pkgData) {
   const content = `# PROJECT SUMMARY
@@ -8625,7 +8839,7 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 - Production: ${Object.keys(pkgData.dependencies).length}
 - Dev: ${Object.keys(pkgData.devDependencies).length}
 `;
-  await fs22.writeFile(path21.join(contextPath, "summary.md"), content, "utf-8");
+  await fs23.writeFile(path22.join(contextPath, "summary.md"), content, "utf-8");
 }
 var execAsync2;
 var init_generator = __esm({
@@ -8648,7 +8862,7 @@ var analysis_exports = {};
 __export(analysis_exports, {
   AnalysisCommands: () => AnalysisCommands
 });
-import path22 from "path";
+import path23 from "path";
 var AnalysisCommands;
 var init_analysis2 = __esm({
   "core/commands/analysis.ts"() {
@@ -8728,7 +8942,7 @@ var init_analysis2 = __esm({
         lines.push("# Repository Analysis\n");
         lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
 `);
-        const projectName = path22.basename(projectPath);
+        const projectName = path23.basename(projectPath);
         lines.push(`## Project: ${projectName}
 `);
         lines.push("## Stack Detected\n");
@@ -8852,7 +9066,7 @@ var planning_exports = {};
 __export(planning_exports, {
   PlanningCommands: () => PlanningCommands
 });
-import path23 from "path";
+import path24 from "path";
 async function getAnalysisCommands() {
   if (!_analysisCommands) {
     const { AnalysisCommands: AnalysisCommands2 } = await Promise.resolve().then(() => (init_analysis2(), analysis_exports));
@@ -8917,7 +9131,7 @@ var init_planning = __esm({
             }, null, 2)
           };
           for (const [filePath, content] of Object.entries(baseFiles)) {
-            await tool_registry_default.get("Write")(path23.join(globalPath, filePath), content);
+            await tool_registry_default.get("Write")(path24.join(globalPath, filePath), content);
           }
           const isEmpty = await this._detectEmptyDirectory(projectPath);
           const hasCode = await this._detectExistingCode(projectPath);
@@ -8938,7 +9152,7 @@ var init_planning = __esm({
               return { success: true, mode: "blank_no_idea", projectId };
             }
             output_default.spin("architect mode...");
-            const sessionPath = path23.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path24.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -9080,7 +9294,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 = path23.join(globalPath, "planning", "architect-session.md");
+          const planPath = path24.join(globalPath, "planning", "architect-session.md");
           let planContent;
           try {
             planContent = await file_helper_exports.readFile(planPath);
@@ -9154,7 +9368,7 @@ ${steps}`);
           if (isComplex) {
             output_default.spin("analyzing idea...");
             const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-            const sessionPath = path23.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path24.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -9209,10 +9423,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!featureName) {
             output_default.spin("loading specs...");
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
-            const specsPath2 = path23.join(globalPath2, "planning", "specs");
+            const specsPath2 = path24.join(globalPath2, "planning", "specs");
             try {
-              const fs24 = await import("fs/promises");
-              const files = await fs24.readdir(specsPath2);
+              const fs25 = await import("fs/promises");
+              const files = await fs25.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -9234,10 +9448,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           }
           output_default.spin("creating spec...");
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-          const specsPath = path23.join(globalPath, "planning", "specs");
+          const specsPath = path24.join(globalPath, "planning", "specs");
           await file_helper_exports.ensureDir(specsPath);
           const slug = featureName.toLowerCase().replace(/\s+/g, "-");
-          const specFile = path23.join(specsPath, `${slug}.md`);
+          const specFile = path24.join(specsPath, `${slug}.md`);
           const specContent = `# Specification: ${featureName}
 
 ## Overview
@@ -9849,18 +10063,18 @@ var init_workflow = __esm({
 });
 
 // core/utils/project-commands.ts
-import path24 from "path";
+import path25 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(path24.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path24.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists(path24.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists(path24.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists(path24.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(path25.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path25.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path25.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path25.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path25.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -9876,7 +10090,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path24.join(projectPath, "package.json");
+  const pkgPath = path25.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -9893,27 +10107,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path24.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path25.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path24.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path25.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path24.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path25.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path24.join(projectPath, "go.mod"))) {
+  if (await fileExists(path25.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(path24.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path25.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path24.join(projectPath, "gradlew")) && (await fileExists(path24.join(projectPath, "build.gradle")) || await fileExists(path24.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path25.join(projectPath, "gradlew")) && (await fileExists(path25.join(projectPath, "build.gradle")) || await fileExists(path25.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -9930,7 +10144,7 @@ var init_project_commands = __esm({
 });
 
 // core/commands/shipping.ts
-import path25 from "path";
+import path26 from "path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -10052,7 +10266,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path25.join(projectPath, "package.json");
+          const pkgPath = path26.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);
@@ -10071,7 +10285,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path25.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path26.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())}
 
@@ -10457,7 +10671,7 @@ var init_registry = __esm({
 });
 
 // core/commands/analytics.ts
-import path26 from "path";
+import path27 from "path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -10482,7 +10696,7 @@ var init_analytics = __esm({
             output_default.fail("no project ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path26.basename(projectPath);
+          const projectName = path27.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -10720,7 +10934,7 @@ ${catInfo?.title || cat}:`);
 });
 
 // core/commands/cleanup.ts
-import path27 from "path";
+import path28 from "path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -10736,7 +10950,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path27.basename(filePath));
+          results.rotated.push(path28.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -10827,7 +11041,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path28 from "path";
+import path29 from "path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -10839,7 +11053,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 = path28.join(
+    const designsPath = path29.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -10879,7 +11093,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path28.join(designsPath, designFileName);
+    const designFilePath = path29.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -10903,7 +11117,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path29 from "path";
+import path30 from "path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -10951,7 +11165,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path29.join(
+    const snapshotsPath = path30.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
@@ -10972,7 +11186,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path29.join(snapshotsPath, "history.json");
+      const snapshotFile = path30.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -11009,11 +11223,11 @@ async function redo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path29.join(
+    const snapshotsPath = path30.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path29.join(snapshotsPath, "history.json");
+    const snapshotFile = path30.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -11069,11 +11283,11 @@ async function history(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path29.join(
+    const snapshotsPath = path30.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path29.join(snapshotsPath, "history.json");
+    const snapshotFile = path30.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -11175,9 +11389,9 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import path30 from "path";
-import fs23 from "fs";
-import os9 from "os";
+import path31 from "path";
+import fs24 from "fs";
+import os10 from "os";
 import chalk4 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -11284,37 +11498,71 @@ var init_setup2 = __esm({
        */
       async installStatusLine() {
         try {
-          const claudeDir = path30.join(os9.homedir(), ".claude");
-          const settingsPath = path30.join(claudeDir, "settings.json");
-          const statusLinePath = path30.join(claudeDir, "prjct-statusline.sh");
+          const claudeDir = path31.join(os10.homedir(), ".claude");
+          const settingsPath = path31.join(claudeDir, "settings.json");
+          const statusLinePath = path31.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
-# Shows \u26A1 prjct with animated spinner when command is running
+# Shows version update notifications and current task
+
+# Current CLI version (embedded at install time)
+CLI_VERSION="${VERSION}"
 
 # Read JSON context from stdin (provided by Claude Code)
 read -r json
 
-# Spinner frames
-frames=('\u280B' '\u2819' '\u2839' '\u2838' '\u283C' '\u2834' '\u2826' '\u2827' '\u2807' '\u280F')
-
-# Calculate frame based on time (changes every 80ms)
-frame=$(($(date +%s%N 2>/dev/null || echo 0) / 80000000 % 10))
-
-# Check if prjct command is running
-running_file="$HOME/.prjct-cli/.running"
-
-if [ -f "$running_file" ]; then
-  task=$(cat "$running_file" 2>/dev/null || echo "working")
-  echo "\u26A1 prjct \${frames[$frame]} $task"
-else
-  echo "\u26A1 prjct"
+# Extract cwd from JSON
+CWD=$(echo "$json" | grep -o '"cwd"[[:space:]]*:[[:space:]]*"[^"]*"' | sed 's/.*"cwd"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+# Check if this is a prjct project
+CONFIG="$CWD/.prjct/prjct.config.json"
+if [[ -f "$CONFIG" ]]; then
+  # Extract projectId
+  PROJECT_ID=$(grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' "$CONFIG" | sed 's/.*"projectId"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+  if [[ -n "$PROJECT_ID" ]]; then
+    PROJECT_JSON="$HOME/.prjct-cli/projects/$PROJECT_ID/project.json"
+
+    # Check version mismatch
+    if [[ -f "$PROJECT_JSON" ]]; then
+      PROJECT_VERSION=$(grep -o '"cliVersion"[[:space:]]*:[[:space:]]*"[^"]*"' "$PROJECT_JSON" | sed 's/.*"cliVersion"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+      # If no cliVersion or different version, show update notice
+      if [[ -z "$PROJECT_VERSION" ]] || [[ "$PROJECT_VERSION" != "$CLI_VERSION" ]]; then
+        echo "\u26A0\uFE0F prjct v$CLI_VERSION available! Run /p:sync"
+        exit 0
+      fi
+    else
+      # No project.json means project needs sync
+      echo "\u26A0\uFE0F prjct v$CLI_VERSION available! Run /p:sync"
+      exit 0
+    fi
+
+    # Show current task if exists
+    STATE="$HOME/.prjct-cli/projects/$PROJECT_ID/storage/state.json"
+    if [[ -f "$STATE" ]]; then
+      TASK=$(grep -o '"description"[[:space:]]*:[[:space:]]*"[^"]*"' "$STATE" | head -1 | sed 's/.*"description"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+      STATUS=$(grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' "$STATE" | head -1 | sed 's/.*"status"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/')
+
+      if [[ -n "$TASK" ]] && [[ "$STATUS" == "active" ]]; then
+        # Truncate task to 40 chars
+        TASK_SHORT="\${TASK:0:40}"
+        [[ \${#TASK} -gt 40 ]] && TASK_SHORT="$TASK_SHORT..."
+        echo "\u{1F3AF} $TASK_SHORT"
+        exit 0
+      fi
+    fi
+  fi
 fi
+
+# Default: show prjct branding
+echo "\u26A1 prjct"
 `;
-          fs23.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs24.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs23.existsSync(settingsPath)) {
+          if (fs24.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs23.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs24.readFileSync(settingsPath, "utf8"));
             } catch {
             }
           }
@@ -11322,7 +11570,7 @@ fi
             type: "command",
             command: statusLinePath
           };
-          fs23.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs24.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -11355,8 +11603,8 @@ fi
         console.log(`  ${chalk4.bold("1.")} Initialize your project:`);
         console.log(`     ${chalk4.green("cd your-project && prjct init")}`);
         console.log("");
-        console.log(`  ${chalk4.bold("2.")} Set your current focus:`);
-        console.log(`     ${chalk4.green('prjct now "build auth"')}`);
+        console.log(`  ${chalk4.bold("2.")} Start your first task:`);
+        console.log(`     ${chalk4.green('prjct task "build auth"')}`);
         console.log("");
         console.log(`  ${chalk4.bold("3.")} Ship & celebrate:`);
         console.log(`     ${chalk4.green('prjct ship "user login"')}`);
@@ -11578,16 +11826,27 @@ var init_command_data = __esm({
         requiresProject: true,
         features: ["Simple ideas -> Quick capture", "Complex ideas -> Full architecture"]
       },
+      {
+        name: "task",
+        group: "core",
+        description: "Start task with agentic classification and 7-phase workflow",
+        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+        params: "<description>",
+        implemented: true,
+        hasTemplate: true,
+        requiresProject: true,
+        features: ["Agentic type classification", "7-phase workflow", "Git branch management", "Task breakdown"]
+      },
       {
         name: "feature",
         group: "core",
-        description: "Add feature with value analysis and task breakdown",
-        usage: { claude: '/p:feature "add testing"', terminal: 'prjct feature "add testing"' },
+        description: "DEPRECATED - Use /p:task instead",
+        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
         params: "<description>",
         implemented: true,
         hasTemplate: true,
         requiresProject: true,
-        features: ["Value analysis", "Auto roadmap generation", "Task breakdown"]
+        deprecated: true
       },
       {
         name: "spec",
@@ -11602,22 +11861,24 @@ var init_command_data = __esm({
       {
         name: "now",
         group: "core",
-        description: "Set or show current task with session tracking",
-        usage: { claude: '/p:now ["task"]', terminal: 'prjct now ["task"]' },
-        params: "[task] [estimate]",
+        description: "DEPRECATED - Use /p:task instead",
+        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+        params: "[task]",
         implemented: true,
         hasTemplate: true,
-        requiresProject: true
+        requiresProject: true,
+        deprecated: true
       },
       {
         name: "work",
         group: "core",
-        description: "Set or show current task (alias for now)",
-        usage: { claude: '/p:work ["task"]', terminal: 'prjct work ["task"]' },
+        description: "DEPRECATED - Use /p:task instead",
+        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
         params: "[task]",
         implemented: true,
         hasTemplate: true,
-        requiresProject: true
+        requiresProject: true,
+        deprecated: true
       },
       {
         name: "pause",
@@ -11942,7 +12203,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.20.0",
+      version: "0.28.0",
       description: "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
       main: "core/index.ts",
       bin: {
@@ -11991,7 +12252,7 @@ var require_package = __commonJS({
       dependencies: {
         "@hono/node-server": "^1.13.7",
         chalk: "^4.1.2",
-        esbuild: "^0.24.2",
+        esbuild: "^0.25.0",
         glob: "^10.3.10",
         hono: "^4.11.3",
         "jsonc-parser": "^3.3.1",
@@ -12040,10 +12301,7 @@ var require_package = __commonJS({
       trustedDependencies: [
         "chalk",
         "prompts"
-      ],
-      overrides: {
-        esbuild: "^0.25.0"
-      }
+      ]
     };
   }
 });