prjct-cli 0.28.4 → 0.29.1

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) => (path32) => {
-  var fn = map[path32];
+var __glob = (map) => (path33) => {
+  var fn = map[path33];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path32);
+  throw new Error("Module not found in bundle: " + path33);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -277,7 +277,7 @@ function formatDuration(milliseconds) {
   }
   return `${seconds}s`;
 }
-function calculateDuration(startDate, endDate = /* @__PURE__ */ new Date()) {
+function calculateDuration2(startDate, endDate = /* @__PURE__ */ new Date()) {
   const milliseconds = endDate.getTime() - startDate.getTime();
   return formatDuration(milliseconds);
 }
@@ -308,7 +308,7 @@ var init_date_helper = __esm({
     __name(isToday, "isToday");
     __name(isWithinLastDays, "isWithinLastDays");
     __name(formatDuration, "formatDuration");
-    __name(calculateDuration, "calculateDuration");
+    __name(calculateDuration2, "calculateDuration");
     __name(getStartOfDay, "getStartOfDay");
     __name(getEndOfDay, "getEndOfDay");
     date_helper_default = {
@@ -325,7 +325,7 @@ var init_date_helper = __esm({
       isToday,
       isWithinLastDays,
       formatDuration,
-      calculateDuration,
+      calculateDuration: calculateDuration2,
       getStartOfDay,
       getEndOfDay
     };
@@ -370,11 +370,11 @@ __export(file_helper_exports, {
   writeJson: () => writeJson,
   writeLines: () => writeLines
 });
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 async function readJson(filePath, defaultValue = null) {
   try {
-    const content = await fs4.readFile(filePath, "utf-8");
+    const content = await fs5.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -385,11 +385,11 @@ async function readJson(filePath, defaultValue = null) {
 }
 async function writeJson(filePath, data, indent = 2) {
   const content = JSON.stringify(data, null, indent);
-  await fs4.writeFile(filePath, content, "utf-8");
+  await fs5.writeFile(filePath, content, "utf-8");
 }
 async function readFile(filePath, defaultValue = "") {
   try {
-    return await fs4.readFile(filePath, "utf-8");
+    return await fs5.readFile(filePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return defaultValue;
@@ -398,32 +398,32 @@ async function readFile(filePath, defaultValue = "") {
   }
 }
 async function writeFile(filePath, content) {
-  const dir = path4.dirname(filePath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.writeFile(filePath, content, "utf-8");
+  const dir = path5.dirname(filePath);
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.writeFile(filePath, content, "utf-8");
 }
 async function atomicWrite(filePath, content) {
-  const dir = path4.dirname(filePath);
-  await fs4.mkdir(dir, { recursive: true });
+  const dir = path5.dirname(filePath);
+  await fs5.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.${Date.now()}.tmp`;
-  await fs4.writeFile(tempPath, content, "utf-8");
-  await fs4.rename(tempPath, filePath);
+  await fs5.writeFile(tempPath, content, "utf-8");
+  await fs5.rename(tempPath, filePath);
 }
 async function appendToFile(filePath, content) {
-  await fs4.appendFile(filePath, content, "utf-8");
+  await fs5.appendFile(filePath, content, "utf-8");
 }
 async function appendLine(filePath, line) {
-  const dir = path4.dirname(filePath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.appendFile(filePath, line + "\n", "utf-8");
+  const dir = path5.dirname(filePath);
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.appendFile(filePath, line + "\n", "utf-8");
 }
 async function prependToFile(filePath, content) {
   try {
-    const existing = await fs4.readFile(filePath, "utf-8");
-    await fs4.writeFile(filePath, content + existing, "utf-8");
+    const existing = await fs5.readFile(filePath, "utf-8");
+    await fs5.writeFile(filePath, content + existing, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
-      await fs4.writeFile(filePath, content, "utf-8");
+      await fs5.writeFile(filePath, content, "utf-8");
     } else {
       throw error;
     }
@@ -431,7 +431,7 @@ async function prependToFile(filePath, content) {
 }
 async function fileExists(filePath) {
   try {
-    await fs4.access(filePath);
+    await fs5.access(filePath);
     return true;
   } catch {
     return false;
@@ -439,18 +439,18 @@ async function fileExists(filePath) {
 }
 async function dirExists(dirPath) {
   try {
-    const stats = await fs4.stat(dirPath);
+    const stats = await fs5.stat(dirPath);
     return stats.isDirectory();
   } catch {
     return false;
   }
 }
 async function ensureDir(dirPath) {
-  await fs4.mkdir(dirPath, { recursive: true });
+  await fs5.mkdir(dirPath, { recursive: true });
 }
 async function deleteFile(filePath) {
   try {
-    await fs4.unlink(filePath);
+    await fs5.unlink(filePath);
     return true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -461,7 +461,7 @@ async function deleteFile(filePath) {
 }
 async function deleteDir(dirPath) {
   try {
-    await fs4.rm(dirPath, { recursive: true, force: true });
+    await fs5.rm(dirPath, { recursive: true, force: true });
     return true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -472,7 +472,7 @@ async function deleteDir(dirPath) {
 }
 async function listFiles(dirPath, options = {}) {
   try {
-    const entries = await fs4.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs5.readdir(dirPath, { withFileTypes: true });
     let files = entries;
     if (options.filesOnly) {
       files = files.filter((entry) => entry.isFile());
@@ -492,18 +492,18 @@ async function listFiles(dirPath, options = {}) {
   }
 }
 async function getFileSize(filePath) {
-  const stats = await fs4.stat(filePath);
+  const stats = await fs5.stat(filePath);
   return stats.size;
 }
 async function getFileModifiedTime(filePath) {
-  const stats = await fs4.stat(filePath);
+  const stats = await fs5.stat(filePath);
   return stats.mtime;
 }
 async function copyFile(sourcePath, destPath) {
-  await fs4.copyFile(sourcePath, destPath);
+  await fs5.copyFile(sourcePath, destPath);
 }
 async function moveFile(oldPath, newPath) {
-  await fs4.rename(oldPath, newPath);
+  await fs5.rename(oldPath, newPath);
 }
 async function readLines(filePath) {
   const content = await readFile(filePath, "");
@@ -514,10 +514,10 @@ async function writeLines(filePath, lines) {
   await writeFile(filePath, content);
 }
 function getFileExtension(filePath) {
-  return path4.extname(filePath);
+  return path5.extname(filePath);
 }
 function getFileNameWithoutExtension(filePath) {
-  return path4.basename(filePath, path4.extname(filePath));
+  return path5.basename(filePath, path5.extname(filePath));
 }
 var file_helper_default;
 var init_file_helper = __esm({
@@ -574,10 +574,10 @@ var init_file_helper = __esm({
 });
 
 // core/infrastructure/path-manager.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 import crypto2 from "crypto";
-import os2 from "os";
+import os3 from "os";
 var PathManager, pathManager, path_manager_default;
 var init_path_manager = __esm({
   "core/infrastructure/path-manager.ts"() {
@@ -593,9 +593,9 @@ var init_path_manager = __esm({
       globalConfigDir;
       constructor() {
         const envOverride = process.env.PRJCT_CLI_HOME?.trim();
-        this.globalBaseDir = envOverride ? path5.resolve(envOverride) : path5.join(os2.homedir(), ".prjct-cli");
-        this.globalProjectsDir = path5.join(this.globalBaseDir, "projects");
-        this.globalConfigDir = path5.join(this.globalBaseDir, "config");
+        this.globalBaseDir = envOverride ? path6.resolve(envOverride) : path6.join(os3.homedir(), ".prjct-cli");
+        this.globalProjectsDir = path6.join(this.globalBaseDir, "projects");
+        this.globalConfigDir = path6.join(this.globalBaseDir, "config");
       }
       /**
        * Override global storage location (primarily for tests and sandboxed environments).
@@ -605,9 +605,9 @@ var init_path_manager = __esm({
        * @param {string} globalBaseDir - Base directory that will contain `projects/` and `config/`.
        */
       setGlobalBaseDir(globalBaseDir) {
-        this.globalBaseDir = path5.resolve(globalBaseDir);
-        this.globalProjectsDir = path5.join(this.globalBaseDir, "projects");
-        this.globalConfigDir = path5.join(this.globalBaseDir, "config");
+        this.globalBaseDir = path6.resolve(globalBaseDir);
+        this.globalProjectsDir = path6.join(this.globalBaseDir, "projects");
+        this.globalConfigDir = path6.join(this.globalBaseDir, "config");
       }
       /**
        * Generate a unique project ID using UUID.
@@ -626,26 +626,26 @@ var init_path_manager = __esm({
        * Get the global storage path for a project
        */
       getGlobalProjectPath(projectId) {
-        return path5.join(this.globalProjectsDir, projectId);
+        return path6.join(this.globalProjectsDir, projectId);
       }
       /**
        * Get the local config file path for a project
        */
       getLocalConfigPath(projectPath) {
-        return path5.join(projectPath, ".prjct", "prjct.config.json");
+        return path6.join(projectPath, ".prjct", "prjct.config.json");
       }
       /**
        * Get the global config file path for a project
        * This file stores authors and other system data that shouldn't be versioned
        */
       getGlobalProjectConfigPath(projectId) {
-        return path5.join(this.getGlobalProjectPath(projectId), "project.json");
+        return path6.join(this.getGlobalProjectPath(projectId), "project.json");
       }
       /**
        * Get the legacy .prjct directory path
        */
       getLegacyPrjctPath(projectPath) {
-        return path5.join(projectPath, ".prjct");
+        return path6.join(projectPath, ".prjct");
       }
       /**
        * Check if a project has legacy .prjct directory
@@ -679,10 +679,10 @@ var init_path_manager = __esm({
         const projectPath = this.getGlobalProjectPath(projectId);
         const layers = ["core", "progress", "planning", "analysis", "memory", "agents"];
         for (const layer of layers) {
-          await ensureDir(path5.join(projectPath, layer));
+          await ensureDir(path6.join(projectPath, layer));
         }
-        await ensureDir(path5.join(projectPath, "planning", "tasks"));
-        await ensureDir(path5.join(projectPath, "sessions"));
+        await ensureDir(path6.join(projectPath, "planning", "tasks"));
+        await ensureDir(path6.join(projectPath, "sessions"));
         return projectPath;
       }
       /**
@@ -691,7 +691,7 @@ var init_path_manager = __esm({
        */
       getSessionPath(projectId, date = /* @__PURE__ */ new Date()) {
         const { year, month, day } = getYearMonthDay(date);
-        return path5.join(this.getGlobalProjectPath(projectId), "sessions", year, month, day);
+        return path6.join(this.getGlobalProjectPath(projectId), "sessions", year, month, day);
       }
       /**
        * Get current session directory path (today)
@@ -711,27 +711,27 @@ var init_path_manager = __esm({
        * List all session dates for a project
        */
       async listSessions(projectId, year = null, month = null) {
-        const sessionsDir = path5.join(this.getGlobalProjectPath(projectId), "sessions");
+        const sessionsDir = path6.join(this.getGlobalProjectPath(projectId), "sessions");
         const sessions = [];
         try {
-          const years = await fs5.readdir(sessionsDir, { withFileTypes: true });
+          const years = await fs6.readdir(sessionsDir, { withFileTypes: true });
           for (const yearEntry of years) {
             if (!yearEntry.isDirectory()) continue;
             if (year && yearEntry.name !== year.toString()) continue;
-            const yearPath = path5.join(sessionsDir, yearEntry.name);
-            const months = await fs5.readdir(yearPath, { withFileTypes: true });
+            const yearPath = path6.join(sessionsDir, yearEntry.name);
+            const months = await fs6.readdir(yearPath, { withFileTypes: true });
             for (const monthEntry of months) {
               if (!monthEntry.isDirectory()) continue;
               if (month && monthEntry.name !== month.toString().padStart(2, "0")) continue;
-              const monthPath = path5.join(yearPath, monthEntry.name);
-              const days = await fs5.readdir(monthPath, { withFileTypes: true });
+              const monthPath = path6.join(yearPath, monthEntry.name);
+              const days = await fs6.readdir(monthPath, { withFileTypes: true });
               for (const dayEntry of days) {
                 if (!dayEntry.isDirectory()) continue;
                 sessions.push({
                   year: yearEntry.name,
                   month: monthEntry.name,
                   day: dayEntry.name,
-                  path: path5.join(monthPath, dayEntry.name),
+                  path: path6.join(monthPath, dayEntry.name),
                   date: /* @__PURE__ */ new Date(`${yearEntry.name}-${monthEntry.name}-${dayEntry.name}`)
                 });
               }
@@ -754,7 +754,7 @@ var init_path_manager = __esm({
        * Get the path for a specific file in the global structure
        */
       getFilePath(projectId, layer, filename) {
-        return path5.join(this.getGlobalProjectPath(projectId), layer, filename);
+        return path6.join(this.getGlobalProjectPath(projectId), layer, filename);
       }
       /**
        * Get all project IDs in global storage
@@ -762,7 +762,7 @@ var init_path_manager = __esm({
       async listProjects() {
         try {
           await this.ensureGlobalStructure();
-          const entries = await fs5.readdir(this.globalProjectsDir, { withFileTypes: true });
+          const entries = await fs6.readdir(this.globalProjectsDir, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
         } catch {
           return [];
@@ -779,7 +779,7 @@ var init_path_manager = __esm({
        * Get the relative path from home directory for display
        */
       getDisplayPath(absolutePath) {
-        const homeDir = os2.homedir();
+        const homeDir = os3.homedir();
         if (absolutePath.startsWith(homeDir)) {
           return absolutePath.replace(homeDir, "~");
         }
@@ -790,33 +790,33 @@ var init_path_manager = __esm({
        * Stored in global config directory, not project-specific
        */
       getAuthConfigPath() {
-        return path5.join(this.globalConfigDir, "auth.json");
+        return path6.join(this.globalConfigDir, "auth.json");
       }
       /**
        * Get the sync pending events file path for a project
        */
       getSyncPendingPath(projectId) {
-        return path5.join(this.getGlobalProjectPath(projectId), "sync", "pending.json");
+        return path6.join(this.getGlobalProjectPath(projectId), "sync", "pending.json");
       }
       /**
        * Get the last sync timestamp file path for a project
        */
       getLastSyncPath(projectId) {
-        return path5.join(this.getGlobalProjectPath(projectId), "sync", "last-sync.json");
+        return path6.join(this.getGlobalProjectPath(projectId), "sync", "last-sync.json");
       }
       /**
        * Get the running status file path (for status signal)
        * Used to indicate when prjct CLI is actively running
        */
       getRunningStatusPath() {
-        return path5.join(this.globalBaseDir, ".running");
+        return path6.join(this.globalBaseDir, ".running");
       }
       /**
        * Get the docs directory path
        * Contains documentation and help files
        */
       getDocsPath() {
-        return path5.join(this.globalBaseDir, "docs");
+        return path6.join(this.globalBaseDir, "docs");
       }
       /**
        * Get the agents directory path for a project
@@ -824,23 +824,23 @@ var init_path_manager = __esm({
        */
       getAgentsPath(projectId) {
         if (projectId) {
-          return path5.join(this.getGlobalProjectPath(projectId), "agents");
+          return path6.join(this.getGlobalProjectPath(projectId), "agents");
         }
-        return path5.join(this.globalBaseDir, "agents");
+        return path6.join(this.globalBaseDir, "agents");
       }
       /**
        * Get the storage file path for a project
        * Convenience method for accessing storage layer files
        */
       getStoragePath(projectId, filename) {
-        return path5.join(this.getGlobalProjectPath(projectId), "storage", filename);
+        return path6.join(this.getGlobalProjectPath(projectId), "storage", filename);
       }
       /**
        * Get the context directory path for a project
        * Contains generated markdown context files
        */
       getContextPath(projectId) {
-        return path5.join(this.getGlobalProjectPath(projectId), "context");
+        return path6.join(this.getGlobalProjectPath(projectId), "context");
       }
     };
     pathManager = new PathManager();
@@ -1130,18 +1130,18 @@ var init_errors = __esm({
 });
 
 // core/infrastructure/config-manager.ts
-import fs6 from "fs/promises";
-import path6 from "path";
-import * as jsonc2 from "jsonc-parser";
+import fs7 from "fs/promises";
+import path7 from "path";
+import * as jsonc3 from "jsonc-parser";
 function parseJsonc(content) {
   const errors = [];
-  const result = jsonc2.parse(content, errors, {
+  const result = jsonc3.parse(content, errors, {
     allowTrailingComma: true,
     disallowComments: false
   });
   if (errors.length > 0) {
     const firstError = errors[0];
-    throw new SyntaxError(`JSON parse error at offset ${firstError.offset}: ${jsonc2.printParseErrorCode(firstError.error)}`);
+    throw new SyntaxError(`JSON parse error at offset ${firstError.offset}: ${jsonc3.printParseErrorCode(firstError.error)}`);
   }
   return result;
 }
@@ -1160,9 +1160,6 @@ var init_config_manager = __esm({
       static {
         __name(this, "ConfigManager");
       }
-      // Cache projectId lookups with TTL (30 seconds) to avoid repeated disk reads
-      projectIdCache = /* @__PURE__ */ new Map();
-      CACHE_TTL = 3e4;
       /**
        * Read the project configuration file
        * Supports both .json and .jsonc formats (with comments)
@@ -1170,7 +1167,7 @@ var init_config_manager = __esm({
       async readConfig(projectPath) {
         try {
           const configPath = path_manager_default.getLocalConfigPath(projectPath);
-          const content = await fs6.readFile(configPath, "utf-8");
+          const content = await fs7.readFile(configPath, "utf-8");
           return parseJsonc(content);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -1186,9 +1183,9 @@ var init_config_manager = __esm({
       async writeConfig(projectPath, config) {
         const configPath = path_manager_default.getLocalConfigPath(projectPath);
         const configDir = path_manager_default.getLegacyPrjctPath(projectPath);
-        await fs6.mkdir(configDir, { recursive: true });
+        await fs7.mkdir(configDir, { recursive: true });
         const content = JSON.stringify(config, null, 2);
-        await fs6.writeFile(configPath, content + "\n", "utf-8");
+        await fs7.writeFile(configPath, content + "\n", "utf-8");
       }
       /**
        * Read the global project configuration file
@@ -1198,7 +1195,7 @@ var init_config_manager = __esm({
       async readGlobalConfig(projectId) {
         try {
           const configPath = path_manager_default.getGlobalProjectConfigPath(projectId);
-          const content = await fs6.readFile(configPath, "utf-8");
+          const content = await fs7.readFile(configPath, "utf-8");
           return parseJsonc(content);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -1214,9 +1211,9 @@ var init_config_manager = __esm({
       async writeGlobalConfig(projectId, config) {
         const configPath = path_manager_default.getGlobalProjectConfigPath(projectId);
         const configDir = path_manager_default.getGlobalProjectPath(projectId);
-        await fs6.mkdir(configDir, { recursive: true });
+        await fs7.mkdir(configDir, { recursive: true });
         const content = JSON.stringify(config, null, 2);
-        await fs6.writeFile(configPath, content + "\n", "utf-8");
+        await fs7.writeFile(configPath, content + "\n", "utf-8");
       }
       /**
        * Ensure global config exists, create if not
@@ -1303,7 +1300,7 @@ var init_config_manager = __esm({
         if (!config || !config.projectId) return true;
         const globalPath = path_manager_default.getGlobalProjectPath(config.projectId);
         try {
-          const coreFiles = await fs6.readdir(path6.join(globalPath, "core"));
+          const coreFiles = await fs7.readdir(path7.join(globalPath, "core"));
           return coreFiles.length === 0;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -1314,23 +1311,13 @@ var init_config_manager = __esm({
       }
       /**
        * Get the project ID from config, or generate it if config doesn't exist
-       * Uses in-memory cache with TTL to avoid repeated disk reads
        */
       async getProjectId(projectPath) {
-        const cached = this.projectIdCache.get(projectPath);
-        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
-          return cached.id;
-        }
         const config = await this.readConfig(projectPath);
-        const id = config?.projectId || path_manager_default.generateProjectId(projectPath);
-        this.projectIdCache.set(projectPath, { id, timestamp: Date.now() });
-        return id;
-      }
-      /**
-       * Clear the projectId cache (useful for testing or after config changes)
-       */
-      clearProjectIdCache() {
-        this.projectIdCache.clear();
+        if (config && config.projectId) {
+          return config.projectId;
+        }
+        return path_manager_default.generateProjectId(projectPath);
       }
       /**
        * Find an author in the authors array by github username
@@ -1416,21 +1403,21 @@ var init_config_manager = __esm({
 });
 
 // core/infrastructure/command-installer.ts
-import fs7 from "fs/promises";
-import path7 from "path";
-import os3 from "os";
+import fs8 from "fs/promises";
+import path8 from "path";
+import os4 from "os";
 async function installDocs() {
   try {
-    const docsDir = path7.join(os3.homedir(), ".prjct-cli", "docs");
-    const templateDocsDir = path7.join(__dirname, "../../templates/global/docs");
-    await fs7.mkdir(docsDir, { recursive: true });
-    const docFiles = await fs7.readdir(templateDocsDir);
+    const docsDir = path8.join(os4.homedir(), ".prjct-cli", "docs");
+    const templateDocsDir = path8.join(__dirname, "../../templates/global/docs");
+    await fs8.mkdir(docsDir, { recursive: true });
+    const docFiles = await fs8.readdir(templateDocsDir);
     for (const file of docFiles) {
       if (file.endsWith(".md")) {
-        const srcPath = path7.join(templateDocsDir, file);
-        const destPath = path7.join(docsDir, file);
-        const content = await fs7.readFile(srcPath, "utf-8");
-        await fs7.writeFile(destPath, content, "utf-8");
+        const srcPath = path8.join(templateDocsDir, file);
+        const destPath = path8.join(docsDir, file);
+        const content = await fs8.readFile(srcPath, "utf-8");
+        await fs8.writeFile(destPath, content, "utf-8");
       }
     }
     return { success: true };
@@ -1448,21 +1435,21 @@ async function installGlobalConfig(claudeConfigPath, detectClaude) {
     };
   }
   try {
-    const claudeDir = path7.join(os3.homedir(), ".claude");
-    await fs7.mkdir(claudeDir, { recursive: true });
-    const globalConfigPath = path7.join(claudeDir, "CLAUDE.md");
-    const templatePath = path7.join(__dirname, "../../templates/global/CLAUDE.md");
-    const templateContent = await fs7.readFile(templatePath, "utf-8");
+    const claudeDir = path8.join(os4.homedir(), ".claude");
+    await fs8.mkdir(claudeDir, { recursive: true });
+    const globalConfigPath = path8.join(claudeDir, "CLAUDE.md");
+    const templatePath = path8.join(__dirname, "../../templates/global/CLAUDE.md");
+    const templateContent = await fs8.readFile(templatePath, "utf-8");
     let existingContent = "";
     let fileExists2 = false;
     try {
-      existingContent = await fs7.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs8.readFile(globalConfigPath, "utf-8");
       fileExists2 = true;
     } catch {
       fileExists2 = false;
     }
     if (!fileExists2) {
-      await fs7.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs8.writeFile(globalConfigPath, templateContent, "utf-8");
       return {
         success: true,
         action: "created",
@@ -1474,7 +1461,7 @@ async function installGlobalConfig(claudeConfigPath, detectClaude) {
       const hasMarkers = existingContent.includes(startMarker) && existingContent.includes(endMarker);
       if (!hasMarkers) {
         const updatedContent = existingContent + "\n\n" + templateContent;
-        await fs7.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await fs8.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "appended",
@@ -1490,7 +1477,7 @@ async function installGlobalConfig(claudeConfigPath, detectClaude) {
           templateContent.indexOf(endMarker) + endMarker.length
         );
         const updatedContent = beforeMarker + prjctSection + afterMarker;
-        await fs7.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await fs8.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "updated",
@@ -1521,17 +1508,17 @@ var init_command_installer = __esm({
       claudeConfigPath;
       templatesDir;
       constructor() {
-        this.homeDir = os3.homedir();
-        this.claudeCommandsPath = path7.join(this.homeDir, ".claude", "commands", "p");
-        this.claudeConfigPath = path7.join(this.homeDir, ".claude");
-        this.templatesDir = path7.join(__dirname, "..", "..", "templates", "commands");
+        this.homeDir = os4.homedir();
+        this.claudeCommandsPath = path8.join(this.homeDir, ".claude", "commands", "p");
+        this.claudeConfigPath = path8.join(this.homeDir, ".claude");
+        this.templatesDir = path8.join(__dirname, "..", "..", "templates", "commands");
       }
       /**
        * Detect if Claude is installed
        */
       async detectClaude() {
         try {
-          await fs7.access(this.claudeConfigPath);
+          await fs8.access(this.claudeConfigPath);
           return true;
         } catch {
           return false;
@@ -1542,7 +1529,7 @@ var init_command_installer = __esm({
        */
       async getCommandFiles() {
         try {
-          const files = await fs7.readdir(this.templatesDir);
+          const files = await fs8.readdir(this.templatesDir);
           return files.filter((f) => f.endsWith(".md"));
         } catch {
           return [
@@ -1581,16 +1568,16 @@ var init_command_installer = __esm({
         }
         try {
           await this.installRouter();
-          await fs7.mkdir(this.claudeCommandsPath, { recursive: true });
+          await fs8.mkdir(this.claudeCommandsPath, { recursive: true });
           const commandFiles = await this.getCommandFiles();
           const installed = [];
           const errors = [];
           for (const file of commandFiles) {
             try {
-              const sourcePath = path7.join(this.templatesDir, file);
-              const destPath = path7.join(this.claudeCommandsPath, file);
-              const content = await fs7.readFile(sourcePath, "utf-8");
-              await fs7.writeFile(destPath, content, "utf-8");
+              const sourcePath = path8.join(this.templatesDir, file);
+              const destPath = path8.join(this.claudeCommandsPath, file);
+              const content = await fs8.readFile(sourcePath, "utf-8");
+              await fs8.writeFile(destPath, content, "utf-8");
               installed.push(file.replace(".md", ""));
             } catch (error) {
               errors.push({ file, error: error.message });
@@ -1619,8 +1606,8 @@ var init_command_installer = __esm({
           const errors = [];
           for (const file of commandFiles) {
             try {
-              const filePath = path7.join(this.claudeCommandsPath, file);
-              await fs7.unlink(filePath);
+              const filePath = path8.join(this.claudeCommandsPath, file);
+              await fs8.unlink(filePath);
               uninstalled.push(file.replace(".md", ""));
             } catch (error) {
               if (error.code !== "ENOENT") {
@@ -1629,7 +1616,7 @@ var init_command_installer = __esm({
             }
           }
           try {
-            await fs7.rmdir(this.claudeCommandsPath);
+            await fs8.rmdir(this.claudeCommandsPath);
           } catch {
           }
           return {
@@ -1656,8 +1643,8 @@ var init_command_installer = __esm({
           };
         }
         try {
-          await fs7.access(this.claudeCommandsPath);
-          const files = await fs7.readdir(this.claudeCommandsPath);
+          await fs8.access(this.claudeCommandsPath);
+          const files = await fs8.readdir(this.claudeCommandsPath);
           const installedCommands = files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
           return {
             installed: installedCommands.length > 0,
@@ -1701,8 +1688,8 @@ var init_command_installer = __esm({
        */
       async verifyTemplate(commandName) {
         try {
-          const templatePath = path7.join(this.templatesDir, `${commandName}.md`);
-          await fs7.access(templatePath);
+          const templatePath = path8.join(this.templatesDir, `${commandName}.md`);
+          await fs8.access(templatePath);
           return true;
         } catch {
           return false;
@@ -1715,10 +1702,10 @@ var init_command_installer = __esm({
        */
       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");
+          const routerSource = path8.join(this.templatesDir, "p.md");
+          const routerDest = path8.join(this.homeDir, ".claude", "commands", "p.md");
+          const content = await fs8.readFile(routerSource, "utf-8");
+          await fs8.writeFile(routerDest, content, "utf-8");
           return true;
         } catch {
           return false;
@@ -1740,11 +1727,11 @@ var init_command_installer = __esm({
         }
         try {
           await this.installRouter();
-          await fs7.mkdir(this.claudeCommandsPath, { recursive: true });
+          await fs8.mkdir(this.claudeCommandsPath, { recursive: true });
           const templateFiles = await this.getCommandFiles();
           let installedFiles = [];
           try {
-            installedFiles = await fs7.readdir(this.claudeCommandsPath);
+            installedFiles = await fs8.readdir(this.claudeCommandsPath);
             installedFiles = installedFiles.filter((f) => f.endsWith(".md"));
           } catch {
             installedFiles = [];
@@ -1758,11 +1745,11 @@ var init_command_installer = __esm({
           };
           for (const file of templateFiles) {
             try {
-              const sourcePath = path7.join(this.templatesDir, file);
-              const destPath = path7.join(this.claudeCommandsPath, file);
+              const sourcePath = path8.join(this.templatesDir, file);
+              const destPath = path8.join(this.claudeCommandsPath, file);
               const exists = installedFiles.includes(file);
-              const content = await fs7.readFile(sourcePath, "utf-8");
-              await fs7.writeFile(destPath, content, "utf-8");
+              const content = await fs8.readFile(sourcePath, "utf-8");
+              await fs8.writeFile(destPath, content, "utf-8");
               if (!exists) {
                 results.added++;
               } else {
@@ -1808,9 +1795,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync } from "child_process";
-import fs8 from "fs";
-import path8 from "path";
-import os4 from "os";
+import fs9 from "fs";
+import path9 from "path";
+import os5 from "os";
 async function hasClaudeCodeCLI() {
   try {
     execSync("which claude", { stdio: "ignore" });
@@ -1872,23 +1859,23 @@ async function run() {
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path8.join(os4.homedir(), ".prjct-cli", "projects");
-    if (!fs8.existsSync(projectsDir)) {
+    const projectsDir = path9.join(os5.homedir(), ".prjct-cli", "projects");
+    if (!fs9.existsSync(projectsDir)) {
       return;
     }
-    const projectDirs = fs8.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = fs9.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)) {
+      const projectJsonPath = path9.join(projectsDir, projectId, "project.json");
+      if (!fs9.existsSync(projectJsonPath)) {
         continue;
       }
       try {
-        const content = fs8.readFileSync(projectJsonPath, "utf8");
+        const content = fs9.readFileSync(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          fs8.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          fs9.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch {
@@ -1900,85 +1887,162 @@ async function migrateProjectsCliVersion() {
   } catch {
   }
 }
+function ensureStatusLineSettings(settingsPath, statusLinePath) {
+  let settings = {};
+  if (fs9.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs9.readFileSync(settingsPath, "utf8"));
+    } catch {
+    }
+  }
+  settings.statusLine = { type: "command", command: statusLinePath };
+  fs9.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
 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 claudeDir = path9.join(os5.homedir(), ".claude");
+    const settingsPath = path9.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path9.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path9.join(os5.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path9.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path9.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path9.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path9.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path9.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path9.join(__dirname, "..", "..", "assets", "statusline");
+    const sourceScript = path9.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path9.join(assetsDir, "themes");
+    const sourceLibDir = path9.join(assetsDir, "lib");
+    const sourceComponentsDir = path9.join(assetsDir, "components");
+    const sourceConfigPath = path9.join(assetsDir, "default-config.json");
+    if (!fs9.existsSync(claudeDir)) {
+      fs9.mkdirSync(claudeDir, { recursive: true });
+    }
+    if (!fs9.existsSync(prjctStatusLineDir)) {
+      fs9.mkdirSync(prjctStatusLineDir, { recursive: true });
+    }
+    if (!fs9.existsSync(prjctThemesDir)) {
+      fs9.mkdirSync(prjctThemesDir, { recursive: true });
+    }
+    if (!fs9.existsSync(prjctLibDir)) {
+      fs9.mkdirSync(prjctLibDir, { recursive: true });
     }
-    const scriptContent = `#!/bin/bash
+    if (!fs9.existsSync(prjctComponentsDir)) {
+      fs9.mkdirSync(prjctComponentsDir, { recursive: true });
+    }
+    if (fs9.existsSync(prjctStatusLinePath)) {
+      const existingContent = fs9.readFileSync(prjctStatusLinePath, "utf8");
+      if (existingContent.includes("CLI_VERSION=")) {
+        const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
+        if (versionMatch && versionMatch[1] !== VERSION) {
+          const updatedContent = existingContent.replace(
+            /CLI_VERSION="[^"]*"/,
+            `CLI_VERSION="${VERSION}"`
+          );
+          fs9.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+        }
+        installStatusLineModules(sourceLibDir, prjctLibDir);
+        installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
+        ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
+        ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
+        return;
+      }
+    }
+    if (fs9.existsSync(sourceScript)) {
+      let scriptContent = fs9.readFileSync(sourceScript, "utf8");
+      scriptContent = scriptContent.replace(
+        /CLI_VERSION="[^"]*"/,
+        `CLI_VERSION="${VERSION}"`
+      );
+      fs9.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      installStatusLineModules(sourceLibDir, prjctLibDir);
+      installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
+      if (fs9.existsSync(sourceThemeDir)) {
+        const themes = fs9.readdirSync(sourceThemeDir);
+        for (const theme of themes) {
+          const src = path9.join(sourceThemeDir, theme);
+          const dest = path9.join(prjctThemesDir, theme);
+          fs9.copyFileSync(src, dest);
+        }
+      }
+      if (!fs9.existsSync(prjctConfigPath) && fs9.existsSync(sourceConfigPath)) {
+        fs9.copyFileSync(sourceConfigPath, prjctConfigPath);
+      }
+    } else {
+      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
+input=$(cat)
+CWD=$(echo "$input" | jq -r '.workspace.current_dir // "~"' 2>/dev/null)
 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
+if [ -f "$CONFIG" ]; then
+  PROJECT_ID=$(jq -r '.projectId // ""' "$CONFIG" 2>/dev/null)
+  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"
+    if [ -f "$PROJECT_JSON" ]; then
+      PROJECT_VERSION=$(jq -r '.cliVersion // ""' "$PROJECT_JSON" 2>/dev/null)
+      if [ -z "$PROJECT_VERSION" ] || [ "$PROJECT_VERSION" != "$CLI_VERSION" ]; then
+        echo "prjct v$CLI_VERSION - 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"
+      echo "prjct v$CLI_VERSION - 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"
+    if [ -f "$STATE" ]; then
+      TASK=$(jq -r '.currentTask.description // ""' "$STATE" 2>/dev/null)
+      if [ -n "$TASK" ]; then
+        echo "$TASK"
         exit 0
       fi
     fi
   fi
 fi
-
-# Default: show prjct branding
-echo "\u26A1 prjct"
+echo "prjct"
 `;
-    fs8.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
-    let settings = {};
-    if (fs8.existsSync(settingsPath)) {
-      try {
-        settings = JSON.parse(fs8.readFileSync(settingsPath, "utf8"));
-      } catch {
+      fs9.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+    }
+    ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
+    ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
+  } catch {
+  }
+}
+function installStatusLineModules(sourceDir, destDir) {
+  if (!fs9.existsSync(sourceDir)) {
+    return;
+  }
+  const files = fs9.readdirSync(sourceDir);
+  for (const file of files) {
+    if (file.endsWith(".sh")) {
+      const src = path9.join(sourceDir, file);
+      const dest = path9.join(destDir, file);
+      fs9.copyFileSync(src, dest);
+      fs9.chmodSync(dest, 493);
+    }
+  }
+}
+function ensureStatusLineSymlink(linkPath, targetPath) {
+  try {
+    if (fs9.existsSync(linkPath)) {
+      const stats = fs9.lstatSync(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = fs9.readlinkSync(linkPath);
+        if (existingTarget === targetPath) {
+          return;
+        }
       }
+      fs9.unlinkSync(linkPath);
     }
-    settings.statusLine = {
-      type: "command",
-      command: statusLinePath
-    };
-    fs8.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    fs9.symlinkSync(targetPath, linkPath);
   } catch {
+    try {
+      if (fs9.existsSync(targetPath)) {
+        fs9.copyFileSync(targetPath, linkPath);
+        fs9.chmodSync(linkPath, 493);
+      }
+    } catch {
+    }
   }
 }
 function showResults(results) {
@@ -2022,7 +2086,10 @@ var init_setup = __esm({
     __name(run, "run");
     setup_default = { run };
     __name(migrateProjectsCliVersion, "migrateProjectsCliVersion");
+    __name(ensureStatusLineSettings, "ensureStatusLineSettings");
     __name(installStatusLine, "installStatusLine");
+    __name(installStatusLineModules, "installStatusLineModules");
+    __name(ensureStatusLineSymlink, "ensureStatusLineSymlink");
     __name(showResults, "showResults");
   }
 });
@@ -2236,7 +2303,7 @@ var init_ideas = __esm({
 
 // core/schemas/roadmap.ts
 import { z as z5 } from "zod";
-var FeatureStatusSchema, FeatureImpactSchema, FeatureTypeSchema, PhaseStatusSchema, FeatureTaskSchema, RoadmapPhaseSchema, RoadmapStrategySchema, FeatureDurationSchema, FeatureItemSchema, RoadmapJsonSchema, DEFAULT_FEATURE;
+var FeatureStatusSchema, FeatureImpactSchema, FeatureTypeSchema, PhaseStatusSchema, QuarterStatusSchema, InferredFromSchema, FeatureTaskSchema, RoadmapPhaseSchema, RoadmapStrategySchema, FeatureDurationSchema, GitCommitSchema, EffortEstimateSchema, EffortActualSchema, FeatureEffortSchema, QuarterCapacitySchema, QuarterSchema, FeatureItemSchema, BacklogItemSchema, RoadmapJsonSchema, DEFAULT_FEATURE;
 var init_roadmap = __esm({
   "core/schemas/roadmap.ts"() {
     "use strict";
@@ -2244,6 +2311,8 @@ var init_roadmap = __esm({
     FeatureImpactSchema = z5.enum(["low", "medium", "high"]);
     FeatureTypeSchema = z5.enum(["feature", "breaking_change", "refactor", "infrastructure"]);
     PhaseStatusSchema = z5.enum(["completed", "active", "planned"]);
+    QuarterStatusSchema = z5.enum(["planned", "active", "completed"]);
+    InferredFromSchema = z5.enum(["git", "git-branch", "manual", "prd"]);
     FeatureTaskSchema = z5.object({
       id: z5.string(),
       // task_xxxxxxxx
@@ -2269,6 +2338,53 @@ var init_roadmap = __esm({
       totalMinutes: z5.number(),
       display: z5.string().optional()
     });
+    GitCommitSchema = z5.object({
+      hash: z5.string(),
+      message: z5.string(),
+      date: z5.string(),
+      author: z5.string().optional()
+    });
+    EffortEstimateSchema = z5.object({
+      hours: z5.number(),
+      confidence: z5.enum(["low", "medium", "high"]).optional(),
+      breakdown: z5.array(z5.object({
+        area: z5.string(),
+        hours: z5.number()
+      })).optional()
+    });
+    EffortActualSchema = z5.object({
+      hours: z5.number().optional(),
+      commits: z5.number().optional(),
+      linesAdded: z5.number().optional(),
+      linesRemoved: z5.number().optional()
+    });
+    FeatureEffortSchema = z5.object({
+      estimated: EffortEstimateSchema.nullable(),
+      actual: EffortActualSchema.nullable()
+    });
+    QuarterCapacitySchema = z5.object({
+      totalHours: z5.number(),
+      allocatedHours: z5.number(),
+      bufferPercent: z5.number().optional()
+      // % reserved for unknowns
+    });
+    QuarterSchema = z5.object({
+      id: z5.string(),
+      // Q1-2026
+      name: z5.string(),
+      // "Q1 2026"
+      theme: z5.string().optional(),
+      // "Foundation"
+      goals: z5.array(z5.string()).optional(),
+      features: z5.array(z5.string()),
+      // Feature IDs
+      capacity: QuarterCapacitySchema.optional(),
+      status: QuarterStatusSchema,
+      startDate: z5.string().optional(),
+      // ISO8601
+      endDate: z5.string().optional()
+      // ISO8601
+    });
     FeatureItemSchema = z5.object({
       id: z5.string(),
       // feat_xxxxxxxx
@@ -2301,13 +2417,59 @@ var init_roadmap = __esm({
       agent: z5.string().optional(),
       // "fe+be", "fe", "be"
       sprintName: z5.string().optional(),
-      completedDate: z5.string().optional()
+      completedDate: z5.string().optional(),
+      // =========================================================================
+      // AI ORCHESTRATION FIELDS (v0.29.0)
+      // =========================================================================
+      // PRD Integration
+      prdId: z5.string().nullable().optional(),
+      // Link to PRD (prd_xxxxxxxx)
+      // Legacy Support (for existing projects)
+      legacy: z5.boolean().optional(),
+      // true = no PRD required
+      inferredFrom: InferredFromSchema.optional(),
+      // git, git-branch, manual, prd
+      // Quarter Planning
+      quarter: z5.string().nullable().optional(),
+      // Q1-2026, etc.
+      // Dependency Tracking
+      dependencies: z5.array(z5.string()).optional(),
+      // Feature IDs this depends on
+      blockedBy: z5.array(z5.string()).optional(),
+      // Feature IDs blocking this
+      // Effort Tracking (for PRD comparison)
+      effortTracking: FeatureEffortSchema.optional(),
+      // Value Scoring (calculated from PRD)
+      valueScore: z5.number().optional(),
+      // Calculated priority score
+      // Git Data (for legacy features)
+      commits: z5.array(GitCommitSchema).optional(),
+      // Commits for this feature
+      branch: z5.string().optional(),
+      // Branch name (for active)
+      commitsAhead: z5.number().optional()
+      // Commits ahead of main
+    });
+    BacklogItemSchema = z5.object({
+      id: z5.string(),
+      title: z5.string(),
+      prdId: z5.string().nullable().optional(),
+      valueScore: z5.number().optional(),
+      effortEstimate: z5.number().optional(),
+      reason: z5.string().optional()
+      // Why in backlog
     });
     RoadmapJsonSchema = z5.object({
       strategy: RoadmapStrategySchema.nullable().optional(),
       features: z5.array(FeatureItemSchema),
-      backlog: z5.array(z5.string()),
-      lastUpdated: z5.string()
+      backlog: z5.array(z5.union([z5.string(), BacklogItemSchema])),
+      // Support both formats
+      lastUpdated: z5.string(),
+      // AI ORCHESTRATION FIELDS (v0.29.0)
+      quarters: z5.array(QuarterSchema).optional(),
+      // Metadata (for git-inferred roadmaps)
+      generatedFrom: z5.enum(["git-history", "manual", "prd"]).optional(),
+      generatedAt: z5.string().optional()
     });
     DEFAULT_FEATURE = {
       date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
@@ -2315,7 +2477,11 @@ var init_roadmap = __esm({
       impact: "medium",
       progress: 0,
       tasks: [],
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      // AI Orchestration defaults
+      prdId: null,
+      legacy: false,
+      quarter: null
     };
   }
 });
@@ -2401,14 +2567,200 @@ var init_analysis = __esm({
 });
 
 // core/schemas/outcomes.ts
+import { z as z7 } from "zod";
+var QualityScoreSchema, SuccessLevelSchema, WorthAssessmentSchema, VarianceReasonSchema, EffortComparisonSchema, MetricResultSchema, AcceptanceCriteriaResultSchema, SuccessTrackingSchema, LearningSchema, LearningsSchema, ROIAssessmentSchema, TaskOutcomeSchema, FeatureOutcomeSchema, AggregateMetricsSchema, OutcomesJsonSchema;
 var init_outcomes = __esm({
   "core/schemas/outcomes.ts"() {
     "use strict";
+    QualityScoreSchema = z7.number().min(1).max(5);
+    SuccessLevelSchema = z7.enum(["exceeded", "met", "partial", "failed"]);
+    WorthAssessmentSchema = z7.enum(["definitely", "probably", "maybe", "no"]);
+    VarianceReasonSchema = z7.enum([
+      "scope_creep",
+      "underestimated_complexity",
+      "technical_debt",
+      "external_blockers",
+      "learning_curve",
+      "requirements_changed",
+      "optimistic_estimate",
+      "team_changes",
+      "other"
+    ]);
+    EffortComparisonSchema = z7.object({
+      estimated: z7.object({
+        hours: z7.number(),
+        confidence: z7.enum(["low", "medium", "high"]).optional(),
+        source: z7.enum(["prd", "manual", "historical"]).optional()
+      }),
+      actual: z7.object({
+        hours: z7.number(),
+        commits: z7.number().optional(),
+        linesAdded: z7.number().optional(),
+        linesRemoved: z7.number().optional(),
+        sessions: z7.number().optional()
+        // Number of work sessions
+      }),
+      variance: z7.object({
+        hours: z7.number(),
+        // actual - estimated
+        percentage: z7.number(),
+        // ((actual - estimated) / estimated) * 100
+        reason: VarianceReasonSchema.optional(),
+        explanation: z7.string().optional()
+      })
+    });
+    MetricResultSchema = z7.object({
+      name: z7.string(),
+      baseline: z7.number().nullable(),
+      target: z7.number(),
+      actual: z7.number(),
+      unit: z7.string(),
+      achieved: z7.boolean(),
+      // actual >= target (or <= for decrease metrics)
+      percentOfTarget: z7.number()
+      // (actual / target) * 100
+    });
+    AcceptanceCriteriaResultSchema = z7.object({
+      criteria: z7.string(),
+      met: z7.boolean(),
+      notes: z7.string().optional()
+    });
+    SuccessTrackingSchema = z7.object({
+      metrics: z7.array(MetricResultSchema),
+      acceptanceCriteria: z7.array(AcceptanceCriteriaResultSchema),
+      overallSuccess: SuccessLevelSchema,
+      successScore: z7.number().min(0).max(100)
+      // Percentage of metrics/criteria met
+    });
+    LearningSchema = z7.object({
+      category: z7.enum([
+        "estimation",
+        "technical",
+        "process",
+        "communication",
+        "tooling",
+        "architecture",
+        "testing",
+        "other"
+      ]),
+      insight: z7.string(),
+      actionable: z7.boolean(),
+      action: z7.string().optional()
+      // What to do differently next time
+    });
+    LearningsSchema = z7.object({
+      whatWorked: z7.array(z7.string()),
+      whatDidnt: z7.array(z7.string()),
+      surprises: z7.array(z7.string()),
+      recommendations: z7.array(LearningSchema)
+    });
+    ROIAssessmentSchema = z7.object({
+      valueDelivered: z7.number().min(1).max(10),
+      // Subjective 1-10 score
+      userImpact: z7.enum(["none", "low", "medium", "high", "critical"]),
+      businessImpact: z7.enum(["none", "low", "medium", "high", "critical"]),
+      // Calculated: (valueDelivered * 10) / (actual hours)
+      roiScore: z7.number(),
+      // Would you build this again knowing what you know now?
+      worthIt: WorthAssessmentSchema,
+      worthItReason: z7.string().optional(),
+      // Comparison to alternatives
+      alternativeConsidered: z7.string().optional(),
+      betterAlternativeExists: z7.boolean().optional()
+    });
+    TaskOutcomeSchema = z7.object({
+      id: z7.string(),
+      // out_task_xxxxxxxx
+      taskId: z7.string(),
+      description: z7.string(),
+      // Time tracking
+      estimatedMinutes: z7.number().optional(),
+      actualMinutes: z7.number(),
+      // Quality
+      completedAsPlanned: z7.boolean(),
+      qualityScore: QualityScoreSchema,
+      // Context
+      blockers: z7.array(z7.string()),
+      agentUsed: z7.string().optional(),
+      skillsUsed: z7.array(z7.string()).optional(),
+      // Timestamps
+      startedAt: z7.string(),
+      completedAt: z7.string()
+    });
+    FeatureOutcomeSchema = z7.object({
+      id: z7.string(),
+      // out_feat_xxxxxxxx
+      // Links
+      featureId: z7.string(),
+      featureName: z7.string(),
+      prdId: z7.string().nullable(),
+      // null for legacy features
+      // Version info
+      version: z7.string().optional(),
+      branch: z7.string().optional(),
+      prUrl: z7.string().optional(),
+      // Effort
+      effort: EffortComparisonSchema,
+      // Success (only if PRD exists)
+      success: SuccessTrackingSchema.optional(),
+      // Learnings
+      learnings: LearningsSchema,
+      // ROI
+      roi: ROIAssessmentSchema,
+      // Overall rating
+      rating: QualityScoreSchema,
+      // Task outcomes (sub-tasks)
+      taskOutcomes: z7.array(TaskOutcomeSchema).optional(),
+      // Timestamps
+      startedAt: z7.string(),
+      shippedAt: z7.string(),
+      reviewedAt: z7.string().optional(),
+      // When impact was captured
+      // Metadata
+      reviewedBy: z7.string().optional(),
+      // Who filled out the impact review
+      legacy: z7.boolean().optional()
+      // Legacy feature (no PRD)
+    });
+    AggregateMetricsSchema = z7.object({
+      totalFeatures: z7.number(),
+      averageEstimationAccuracy: z7.number(),
+      // Percentage
+      averageSuccessRate: z7.number(),
+      // Percentage
+      averageROI: z7.number(),
+      // By category
+      bySuccessLevel: z7.object({
+        exceeded: z7.number(),
+        met: z7.number(),
+        partial: z7.number(),
+        failed: z7.number()
+      }),
+      // Variance patterns
+      variancePatterns: z7.array(z7.object({
+        reason: VarianceReasonSchema,
+        count: z7.number(),
+        averageVariance: z7.number()
+      })),
+      // Top learnings (aggregated)
+      topLearnings: z7.array(z7.object({
+        insight: z7.string(),
+        frequency: z7.number()
+      }))
+    });
+    OutcomesJsonSchema = z7.object({
+      outcomes: z7.array(FeatureOutcomeSchema),
+      taskOutcomes: z7.array(TaskOutcomeSchema).optional(),
+      // Standalone task outcomes
+      aggregates: AggregateMetricsSchema.optional(),
+      lastUpdated: z7.string(),
+      lastAggregated: z7.string().optional()
+    });
   }
 });
 
 // core/schemas/permissions.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function buildDefaultPermissions() {
   const bash = {};
   for (const pattern of DEFAULT_BASH_ALLOW) {
@@ -2441,20 +2793,20 @@ var PermissionLevelSchema, FileOperationSchema, BashPermissionSchema, FilePermis
 var init_permissions = __esm({
   "core/schemas/permissions.ts"() {
     "use strict";
-    PermissionLevelSchema = z7.enum(["allow", "deny", "ask"]);
-    FileOperationSchema = z7.enum(["read", "write", "delete", "create"]);
-    BashPermissionSchema = z7.record(z7.string(), PermissionLevelSchema);
-    FilePermissionSchema = z7.record(z7.string(), PermissionLevelSchema);
-    WebPermissionSchema = z7.object({
-      enabled: z7.boolean().default(true),
-      allowedDomains: z7.array(z7.string()).optional(),
-      blockedDomains: z7.array(z7.string()).optional()
+    PermissionLevelSchema = z8.enum(["allow", "deny", "ask"]);
+    FileOperationSchema = z8.enum(["read", "write", "delete", "create"]);
+    BashPermissionSchema = z8.record(z8.string(), PermissionLevelSchema);
+    FilePermissionSchema = z8.record(z8.string(), PermissionLevelSchema);
+    WebPermissionSchema = z8.object({
+      enabled: z8.boolean().default(true),
+      allowedDomains: z8.array(z8.string()).optional(),
+      blockedDomains: z8.array(z8.string()).optional()
     });
-    PermissionsConfigSchema = z7.object({
+    PermissionsConfigSchema = z8.object({
       /** Bash command permissions - glob patterns */
       bash: BashPermissionSchema.optional(),
       /** File operation permissions - glob patterns */
-      files: z7.object({
+      files: z8.object({
         read: FilePermissionSchema.optional(),
         write: FilePermissionSchema.optional(),
         delete: FilePermissionSchema.optional()
@@ -2462,11 +2814,11 @@ var init_permissions = __esm({
       /** Web fetch permissions */
       web: WebPermissionSchema.optional(),
       /** Skill invocation permissions */
-      skills: z7.record(z7.string(), PermissionLevelSchema).optional(),
+      skills: z8.record(z8.string(), PermissionLevelSchema).optional(),
       /** Doom loop protection - prevent infinite retries */
-      doomLoop: z7.object({
-        enabled: z7.boolean().default(true),
-        maxRetries: z7.number().default(3)
+      doomLoop: z8.object({
+        enabled: z8.boolean().default(true),
+        maxRetries: z8.number().default(3)
       }).optional(),
       /** External directory access */
       externalDirectories: PermissionLevelSchema.default("ask")
@@ -2552,56 +2904,19 @@ var init_schemas2 = __esm({
 });
 
 // core/agentic/template-loader.ts
-import fs9 from "fs/promises";
-import path9 from "path";
-function setWithLru(key, value) {
-  cache.delete(key);
-  cache.set(key, value);
-  if (cache.size > MAX_CACHE_SIZE) {
-    const oldest = cache.keys().next().value;
+import fs10 from "fs/promises";
+import path10 from "path";
+function updateLruOrder(key) {
+  const index = cacheOrder.indexOf(key);
+  if (index > -1) cacheOrder.splice(index, 1);
+  cacheOrder.push(key);
+}
+function evictLru() {
+  while (cache.size >= MAX_CACHE_SIZE && cacheOrder.length > 0) {
+    const oldest = cacheOrder.shift();
     if (oldest) cache.delete(oldest);
   }
 }
-function getWithLru(key) {
-  const value = cache.get(key);
-  if (value !== void 0) {
-    cache.delete(key);
-    cache.set(key, value);
-  }
-  return value;
-}
-function parseToolPermissions(lines, startIndex) {
-  const permissions = {};
-  let i = startIndex;
-  let currentTool = null;
-  while (i < lines.length) {
-    const line = lines[i];
-    const trimmed = line.trim();
-    if (line.length > 0 && !line.startsWith(" ") && !line.startsWith("	")) {
-      break;
-    }
-    const toolMatch = line.match(/^ {2}(\w+):$/);
-    if (toolMatch) {
-      currentTool = toolMatch[1];
-      permissions[currentTool] = {};
-      i++;
-      continue;
-    }
-    const permMatch = line.match(/^ {4}(allow|ask|deny):\s*\[(.+)\]/);
-    if (permMatch && currentTool) {
-      const [, permType, arrayContent] = permMatch;
-      permissions[currentTool][permType] = arrayContent.split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
-      i++;
-      continue;
-    }
-    if (trimmed === "") {
-      i++;
-      continue;
-    }
-    i++;
-  }
-  return { permissions, endIndex: i };
-}
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\n([\s\S]+?)\n---\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -2610,39 +2925,31 @@ function parseFrontmatter(content) {
   }
   const [, frontmatterText, mainContent] = match;
   const frontmatter = {};
-  const lines = frontmatterText.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
+  frontmatterText.split("\n").forEach((line) => {
     const [key, ...valueParts] = line.split(":");
-    if (!key || line.startsWith(" ") || line.startsWith("	")) {
-      continue;
-    }
-    const keyTrimmed = key.trim();
-    const value = valueParts.join(":").trim();
-    if (keyTrimmed === "tool-permissions" && value === "") {
-      const { permissions, endIndex } = parseToolPermissions(lines, i + 1);
-      frontmatter["tool-permissions"] = permissions;
-      i = endIndex - 1;
-      continue;
-    }
-    if (value.startsWith("[") && value.endsWith("]")) {
-      frontmatter[keyTrimmed] = value.slice(1, -1).split(",").map((v) => v.trim());
-    } else if (value) {
-      frontmatter[keyTrimmed] = value.replace(/^["']|["']$/g, "");
+    if (key && valueParts.length > 0) {
+      const value = valueParts.join(":").trim();
+      if (value.startsWith("[") && value.endsWith("]")) {
+        frontmatter[key.trim()] = value.slice(1, -1).split(",").map((v) => v.trim());
+      } else {
+        frontmatter[key.trim()] = value.replace(/^["']|["']$/g, "");
+      }
     }
-  }
+  });
   return { frontmatter, content: mainContent.trim() };
 }
 async function load(commandName) {
-  const cached = getWithLru(commandName);
-  if (cached) {
-    return cached;
+  if (cache.has(commandName)) {
+    updateLruOrder(commandName);
+    return cache.get(commandName);
   }
-  const templatePath = path9.join(TEMPLATES_DIR, `${commandName}.md`);
+  const templatePath = path10.join(TEMPLATES_DIR, `${commandName}.md`);
   try {
-    const rawContent = await fs9.readFile(templatePath, "utf-8");
+    const rawContent = await fs10.readFile(templatePath, "utf-8");
     const parsed = parseFrontmatter(rawContent);
-    setWithLru(commandName, parsed);
+    evictLru();
+    cache.set(commandName, parsed);
+    cacheOrder.push(commandName);
     return parsed;
   } catch {
     throw TemplateError.notFound(commandName);
@@ -2654,18 +2961,19 @@ async function getAllowedTools(commandName) {
 }
 function clearCache() {
   cache.clear();
+  cacheOrder.length = 0;
 }
-var TEMPLATES_DIR, MAX_CACHE_SIZE, cache, template_loader_default;
+var TEMPLATES_DIR, MAX_CACHE_SIZE, cache, cacheOrder, template_loader_default;
 var init_template_loader = __esm({
   "core/agentic/template-loader.ts"() {
     "use strict";
     init_errors();
-    TEMPLATES_DIR = path9.join(__dirname, "..", "..", "templates", "commands");
+    TEMPLATES_DIR = path10.join(__dirname, "..", "..", "templates", "commands");
     MAX_CACHE_SIZE = 50;
     cache = /* @__PURE__ */ new Map();
-    __name(setWithLru, "setWithLru");
-    __name(getWithLru, "getWithLru");
-    __name(parseToolPermissions, "parseToolPermissions");
+    cacheOrder = [];
+    __name(updateLruOrder, "updateLruOrder");
+    __name(evictLru, "evictLru");
     __name(parseFrontmatter, "parseFrontmatter");
     __name(load, "load");
     __name(getAllowedTools, "getAllowedTools");
@@ -2680,7 +2988,7 @@ var init_template_loader = __esm({
 });
 
 // core/agentic/context-builder.ts
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 var ContextBuilder, contextBuilder, context_builder_default;
 var init_context_builder = __esm({
   "core/agentic/context-builder.ts"() {
@@ -2758,7 +3066,7 @@ var init_context_builder = __esm({
         for (const [, filePath] of filteredEntries) {
           if (this._cache.has(filePath)) {
             try {
-              const stat = await fs10.stat(filePath);
+              const stat = await fs11.stat(filePath);
               const cachedMtime = this._mtimes.get(filePath);
               if (!cachedMtime || stat.mtimeMs > cachedMtime) {
                 this._cache.delete(filePath);
@@ -2781,7 +3089,7 @@ var init_context_builder = __esm({
         if (uncachedEntries.length > 0) {
           const readPromises = uncachedEntries.map(async ([key, filePath]) => {
             try {
-              const [content, stat] = await Promise.all([fs10.readFile(filePath, "utf-8"), fs10.stat(filePath)]);
+              const [content, stat] = await Promise.all([fs11.readFile(filePath, "utf-8"), fs11.stat(filePath)]);
               return { key, filePath, content, mtime: stat.mtimeMs };
             } catch {
               return { key, filePath, content: null, mtime: null };
@@ -2851,7 +3159,7 @@ var init_context_builder = __esm({
         if (uncachedPaths.length > 0) {
           const readPromises = uncachedPaths.map(async (filePath) => {
             try {
-              const content = await fs10.readFile(filePath, "utf-8");
+              const content = await fs11.readFile(filePath, "utf-8");
               return { filePath, content };
             } catch {
               return { filePath, content: null };
@@ -2882,7 +3190,7 @@ var init_context_builder = __esm({
        */
       async fileExists(filePath) {
         try {
-          await fs10.access(filePath);
+          await fs11.access(filePath);
           return true;
         } catch {
           return false;
@@ -3087,8 +3395,8 @@ var init_cache = __esm({
 });
 
 // core/storage/storage-manager.ts
-import fs11 from "fs/promises";
-import path10 from "path";
+import fs12 from "fs/promises";
+import path11 from "path";
 var StorageManager;
 var init_storage_manager = __esm({
   "core/storage/storage-manager.ts"() {
@@ -3131,7 +3439,7 @@ var init_storage_manager = __esm({
         }
         const filePath = this.getStoragePath(projectId);
         try {
-          const content = await fs11.readFile(filePath, "utf-8");
+          const content = await fs12.readFile(filePath, "utf-8");
           const data = JSON.parse(content);
           this.cache.set(projectId, data);
           return data;
@@ -3145,13 +3453,13 @@ var init_storage_manager = __esm({
       async write(projectId, data) {
         const storagePath = this.getStoragePath(projectId);
         const contextPath = this.getContextPath(projectId, this.getMdFilename());
-        await fs11.mkdir(path10.dirname(storagePath), { recursive: true });
-        await fs11.mkdir(path10.dirname(contextPath), { recursive: true });
+        await fs12.mkdir(path11.dirname(storagePath), { recursive: true });
+        await fs12.mkdir(path11.dirname(contextPath), { recursive: true });
         const tempPath = `${storagePath}.${Date.now()}.tmp`;
-        await fs11.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-        await fs11.rename(tempPath, storagePath);
+        await fs12.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+        await fs12.rename(tempPath, storagePath);
         const md2 = this.toMarkdown(data);
-        await fs11.writeFile(contextPath, md2, "utf-8");
+        await fs12.writeFile(contextPath, md2, "utf-8");
         this.cache.set(projectId, data);
       }
       /**
@@ -3199,7 +3507,7 @@ var init_storage_manager = __esm({
       async exists(projectId) {
         const filePath = this.getStoragePath(projectId);
         try {
-          await fs11.access(filePath);
+          await fs12.access(filePath);
           return true;
         } catch {
           return false;
@@ -4250,9 +4558,9 @@ var init_shipped_storage = __esm({
 });
 
 // core/storage/storage.ts
-import fs12 from "fs/promises";
-import path11 from "path";
-import os5 from "os";
+import fs13 from "fs/promises";
+import path12 from "path";
+import os6 from "os";
 function getStorage(projectId) {
   return new FileStorage(projectId);
 }
@@ -4269,7 +4577,7 @@ var init_storage = __esm({
       basePath;
       constructor(projectId) {
         this.projectId = projectId;
-        this.basePath = path11.join(os5.homedir(), ".prjct-cli/projects", projectId, "data");
+        this.basePath = path12.join(os6.homedir(), ".prjct-cli/projects", projectId, "data");
       }
       /**
        * Convert path array to file path
@@ -4278,17 +4586,17 @@ var init_storage = __esm({
        */
       pathToFile(pathArray) {
         if (pathArray.length === 1) {
-          return path11.join(this.basePath, `${pathArray[0]}.json`);
+          return path12.join(this.basePath, `${pathArray[0]}.json`);
         }
         const dir = pathArray[0] + "s";
         const rest = pathArray.slice(1);
         const filename = rest.join("/") + ".json";
-        return path11.join(this.basePath, dir, filename);
+        return path12.join(this.basePath, dir, filename);
       }
       async write(pathArray, data) {
         const filePath = this.pathToFile(pathArray);
-        await fs12.mkdir(path11.dirname(filePath), { recursive: true });
-        await fs12.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs13.mkdir(path12.dirname(filePath), { recursive: true });
+        await fs13.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
         eventBus.publish({
           type: inferEventType(pathArray, "write"),
           path: pathArray,
@@ -4303,16 +4611,16 @@ var init_storage = __esm({
       async read(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          const content = await fs12.readFile(filePath, "utf-8");
+          const content = await fs13.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
         }
       }
       async list(prefix) {
-        const dir = path11.join(this.basePath, prefix[0] + "s");
+        const dir = path12.join(this.basePath, prefix[0] + "s");
         try {
-          const files = await fs12.readdir(dir);
+          const files = await fs13.readdir(dir);
           return files.filter((f) => f.endsWith(".json") && f !== "index.json").map((f) => [...prefix, f.replace(".json", "")]);
         } catch {
           return [];
@@ -4321,7 +4629,7 @@ var init_storage = __esm({
       async delete(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs12.unlink(filePath);
+          await fs13.unlink(filePath);
           eventBus.publish({
             type: inferEventType(pathArray, "delete"),
             path: pathArray,
@@ -4338,7 +4646,7 @@ var init_storage = __esm({
       async exists(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs12.access(filePath);
+          await fs13.access(filePath);
           return true;
         } catch {
           return false;
@@ -4348,10 +4656,10 @@ var init_storage = __esm({
        * Update collection index
        */
       async updateIndex(collection, id, action) {
-        const indexPath = path11.join(this.basePath, collection + "s", "index.json");
+        const indexPath = path12.join(this.basePath, collection + "s", "index.json");
         let index = { ids: [], updatedAt: "" };
         try {
-          const content = await fs12.readFile(indexPath, "utf-8");
+          const content = await fs13.readFile(indexPath, "utf-8");
           index = JSON.parse(content);
         } catch {
         }
@@ -4361,8 +4669,8 @@ var init_storage = __esm({
           index.ids = index.ids.filter((i) => i !== id);
         }
         index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await fs12.mkdir(path11.dirname(indexPath), { recursive: true });
-        await fs12.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+        await fs13.mkdir(path12.dirname(indexPath), { recursive: true });
+        await fs13.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
       }
     };
     __name(getStorage, "getStorage");
@@ -4383,7 +4691,7 @@ var init_storage2 = __esm({
 });
 
 // core/outcomes/recorder.ts
-import path12 from "path";
+import path13 from "path";
 var OUTCOMES_DIR, OUTCOMES_FILE, OutcomeRecorder, outcomeRecorder, recorder_default;
 var init_recorder = __esm({
   "core/outcomes/recorder.ts"() {
@@ -4402,13 +4710,13 @@ var init_recorder = __esm({
        */
       getOutcomesDir(projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-        return path12.join(globalPath, OUTCOMES_DIR);
+        return path13.join(globalPath, OUTCOMES_DIR);
       }
       /**
        * Get outcomes file path for a project.
        */
       getOutcomesPath(projectId) {
-        return path12.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
+        return path13.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
       }
       /**
        * Record an outcome.
@@ -4419,7 +4727,7 @@ var init_recorder = __esm({
           id: generateUUID()
         };
         const outcomesPath = this.getOutcomesPath(projectId);
-        await ensureDir(path12.dirname(outcomesPath));
+        await ensureDir(path13.dirname(outcomesPath));
         await appendLine(outcomesPath, JSON.stringify(outcome));
         return outcome;
       }
@@ -4786,6 +5094,21 @@ var init_memory = __esm({
   }
 });
 
+// core/integrations/issue-tracker/types.ts
+var init_types = __esm({
+  "core/integrations/issue-tracker/types.ts"() {
+    "use strict";
+  }
+});
+
+// core/types/integrations.ts
+var init_integrations = __esm({
+  "core/types/integrations.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
 // core/types/bus.ts
 var init_bus = __esm({
   "core/types/bus.ts"() {
@@ -4794,11 +5117,12 @@ var init_bus = __esm({
 });
 
 // core/types/index.ts
-var init_types = __esm({
+var init_types2 = __esm({
   "core/types/index.ts"() {
     "use strict";
     init_fs();
     init_memory();
+    init_integrations();
     init_bus();
   }
 });
@@ -4809,13 +5133,13 @@ var init_outcomes2 = __esm({
     "use strict";
     init_recorder();
     init_analyzer();
-    init_types();
+    init_types2();
   }
 });
 
 // core/agentic/prompt-builder.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 var PromptBuilder, promptBuilder, prompt_builder_default;
 var init_prompt_builder = __esm({
   "core/agentic/prompt-builder.ts"() {
@@ -4849,14 +5173,14 @@ var init_prompt_builder = __esm({
        */
       loadChecklists() {
         if (this._checklistsCache) return this._checklistsCache;
-        const checklistsDir = path13.join(__dirname, "..", "..", "templates", "checklists");
+        const checklistsDir = path14.join(__dirname, "..", "..", "templates", "checklists");
         const checklists = {};
         try {
-          if (fs13.existsSync(checklistsDir)) {
-            const files = fs13.readdirSync(checklistsDir).filter((f) => f.endsWith(".md"));
+          if (fs14.existsSync(checklistsDir)) {
+            const files = fs14.readdirSync(checklistsDir).filter((f) => f.endsWith(".md"));
             for (const file of files) {
               const name = file.replace(".md", "");
-              const content = fs13.readFileSync(path13.join(checklistsDir, file), "utf-8");
+              const content = fs14.readFileSync(path14.join(checklistsDir, file), "utf-8");
               checklists[name] = content;
             }
           }
@@ -4957,10 +5281,10 @@ var init_prompt_builder = __esm({
        */
       loadChecklistRouting() {
         if (this._checklistRoutingCache) return this._checklistRoutingCache;
-        const routingPath = path13.join(__dirname, "..", "..", "templates", "agentic", "checklist-routing.md");
+        const routingPath = path14.join(__dirname, "..", "..", "templates", "agentic", "checklist-routing.md");
         try {
-          if (fs13.existsSync(routingPath)) {
-            this._checklistRoutingCache = fs13.readFileSync(routingPath, "utf-8");
+          if (fs14.existsSync(routingPath)) {
+            this._checklistRoutingCache = fs14.readFileSync(routingPath, "utf-8");
           }
         } catch {
         }
@@ -4999,7 +5323,7 @@ var init_prompt_builder = __esm({
         const parts = [];
         this._currentContext = context;
         const commandName = template.frontmatter?.name?.replace("p:", "") || "";
-        const agentCommands = ["task", "design", "fix", "bug", "test", "cleanup", "spec"];
+        const agentCommands = ["now", "build", "feature", "design", "fix", "bug", "test", "work", "cleanup", "spec"];
         const needsAgent = agentCommands.includes(commandName);
         if (agent && needsAgent) {
           parts.push(`# AGENT: ${agent.name}
@@ -5046,7 +5370,7 @@ Read files before modifying.
 
 `);
         }
-        const codeCommands = ["task", "design", "cleanup", "fix", "bug", "test", "init", "spec"];
+        const codeCommands = ["now", "build", "feature", "design", "cleanup", "fix", "bug", "test", "init", "spec", "work"];
         const needsPatterns = codeCommands.includes(commandName);
         const codePatternsContent = state?.codePatterns || "";
         if (needsPatterns && codePatternsContent && codePatternsContent.trim()) {
@@ -5196,71 +5520,6 @@ ${content.substring(0, 500)}... (truncated, use Read tool for full content)`
         const result = parts.join("\n").substring(0, 800);
         return result || null;
       }
-      /**
-       * Claude Code subagents that can be invoked via @ notation
-       */
-      CLAUDE_SUBAGENTS = ["explore", "general", "plan"];
-      /**
-       * Parse @ agent mentions from input
-       * Separates prjct agents from Claude Code subagents
-       * @example "@frontend @explore add dark mode" -> { prjctAgents: ["frontend"], claudeSubagents: ["explore"], cleanInput: "add dark mode" }
-       */
-      parseAgentMentions(input) {
-        if (!input) return { prjctAgents: [], claudeSubagents: [], cleanInput: "" };
-        const mentionPattern = /@(\w+)/g;
-        const prjctAgents = [];
-        const claudeSubagents = [];
-        let match;
-        while ((match = mentionPattern.exec(input)) !== null) {
-          const name = match[1].toLowerCase();
-          if (this.CLAUDE_SUBAGENTS.includes(name)) {
-            claudeSubagents.push(name);
-          } else {
-            prjctAgents.push(name);
-          }
-        }
-        const cleanInput = input.replace(mentionPattern, "").trim();
-        return { prjctAgents, claudeSubagents, cleanInput };
-      }
-      /**
-       * Build Claude subagent instructions for the prompt
-       */
-      buildSubagentInstructions(claudeSubagents) {
-        if (!claudeSubagents.length) return "";
-        const instructions = claudeSubagents.map((sub) => {
-          switch (sub) {
-            case "explore":
-              return "- USE Task tool with subagent_type=Explore for fast codebase exploration";
-            case "general":
-              return "- USE Task tool with subagent_type=general-purpose for complex multi-step research";
-            case "plan":
-              return "- USE Task tool with subagent_type=Plan for architecture design";
-            default:
-              return null;
-          }
-        }).filter(Boolean);
-        if (!instructions.length) return "";
-        return `
-## CLAUDE SUBAGENT INSTRUCTIONS
-${instructions.join("\n")}
-`;
-      }
-      /**
-       * Build tool permissions section from template frontmatter
-       */
-      buildToolPermissions(toolPermissions) {
-        if (!toolPermissions) return "";
-        const parts = ["\n## TOOL PERMISSIONS\n", "Check these BEFORE executing:\n"];
-        for (const [tool, rules] of Object.entries(toolPermissions)) {
-          parts.push(`
-**${tool}:**`);
-          if (rules.allow?.length) parts.push(`- ALLOW: ${rules.allow.join(", ")}`);
-          if (rules.ask?.length) parts.push(`- ASK USER: ${rules.ask.join(", ")}`);
-          if (rules.deny?.length) parts.push(`- NEVER: ${rules.deny.join(", ")}`);
-        }
-        parts.push("\n\u26A0\uFE0F DENY = Never execute. ASK = Confirm with user first.\n");
-        return parts.join("\n");
-      }
       /**
        * Build critical anti-hallucination rules section
        */
@@ -5283,7 +5542,7 @@ Context: ${fileCount} files available. Read what you need.
 });
 
 // core/agentic/tool-registry.ts
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync, toolRegistry, tool_registry_default;
@@ -5328,14 +5587,14 @@ var init_tool_registry = __esm({
     };
     toolRegistry.register("Read", async (filePath) => {
       try {
-        return await fs14.readFile(filePath, "utf-8");
+        return await fs15.readFile(filePath, "utf-8");
       } catch {
         return null;
       }
     });
     toolRegistry.register("Write", async (filePath, content) => {
       try {
-        await fs14.writeFile(filePath, content, "utf-8");
+        await fs15.writeFile(filePath, content, "utf-8");
         return true;
       } catch {
         return false;
@@ -5806,10 +6065,10 @@ var init_chain_of_thought = __esm({
 });
 
 // core/utils/jsonl-helper.ts
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import fsSync from "fs";
 import readline from "readline";
-import path14 from "path";
+import path15 from "path";
 function parseJsonLines(content) {
   const lines = content.split("\n").filter((line) => line.trim());
   const entries = [];
@@ -5826,7 +6085,7 @@ function stringifyJsonLines(objects) {
 }
 async function readJsonLines(filePath) {
   try {
-    const content = await fs15.readFile(filePath, "utf-8");
+    const content = await fs16.readFile(filePath, "utf-8");
     return parseJsonLines(content);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -5837,15 +6096,15 @@ async function readJsonLines(filePath) {
 }
 async function writeJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs15.writeFile(filePath, content, "utf-8");
+  await fs16.writeFile(filePath, content, "utf-8");
 }
 async function appendJsonLine(filePath, object) {
   const line = JSON.stringify(object) + "\n";
-  await fs15.appendFile(filePath, line, "utf-8");
+  await fs16.appendFile(filePath, line, "utf-8");
 }
 async function appendJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs15.appendFile(filePath, content, "utf-8");
+  await fs16.appendFile(filePath, content, "utf-8");
 }
 async function filterJsonLines(filePath, predicate) {
   const entries = await readJsonLines(filePath);
@@ -5853,7 +6112,7 @@ async function filterJsonLines(filePath, predicate) {
 }
 async function countJsonLines(filePath) {
   try {
-    const content = await fs15.readFile(filePath, "utf-8");
+    const content = await fs16.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return lines.length;
   } catch (error) {
@@ -5912,7 +6171,7 @@ async function readJsonLinesStreaming(filePath, maxLines = 1e3) {
 }
 async function getFileSizeMB(filePath) {
   try {
-    const stats = await fs15.stat(filePath);
+    const stats = await fs16.stat(filePath);
     return stats.size / (1024 * 1024);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -5927,12 +6186,12 @@ async function rotateJsonLinesIfNeeded(filePath, maxSizeMB = 10) {
     return false;
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  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)}`);
+  const dir = path15.dirname(filePath);
+  const ext = path15.extname(filePath);
+  const base = path15.basename(filePath, ext);
+  const archivePath = path15.join(dir, `${base}-${timestamp}${ext}`);
+  await fs16.rename(filePath, archivePath);
+  console.log(`\u{1F4E6} Rotated ${path15.basename(filePath)} (${sizeMB.toFixed(1)}MB) \u2192 ${path15.basename(archivePath)}`);
   return true;
 }
 async function appendJsonLineWithRotation(filePath, object, maxSizeMB = 10) {
@@ -5944,7 +6203,7 @@ async function checkFileSizeWarning(filePath, warnThresholdMB = 50) {
   const isLarge = sizeMB > warnThresholdMB;
   if (isLarge) {
     console.warn(
-      `\u26A0\uFE0F  Large file detected: ${path14.basename(filePath)} (${sizeMB.toFixed(1)}MB). Reading may use significant memory.`
+      `\u26A0\uFE0F  Large file detected: ${path15.basename(filePath)} (${sizeMB.toFixed(1)}MB). Reading may use significant memory.`
     );
   }
   return { sizeMB, isLarge };
@@ -5994,8 +6253,8 @@ var init_jsonl_helper = __esm({
 });
 
 // core/agentic/memory-system.ts
-import fs16 from "fs/promises";
-import path15 from "path";
+import fs17 from "fs/promises";
+import path16 from "path";
 var CachedStore, SessionStore, HistoryStore, PatternStore, SemanticMemories, MemorySystem, memorySystem, memory_system_default;
 var init_memory_system = __esm({
   "core/agentic/memory-system.ts"() {
@@ -6025,12 +6284,12 @@ var init_memory_system = __esm({
        * Get full path for the store file
        */
       getPath(projectId) {
-        const basePath = path15.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
+        const basePath = path16.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
         const subdir = this.getSubdirectory();
         if (subdir) {
-          return path15.join(basePath, subdir, this.getFilename());
+          return path16.join(basePath, subdir, this.getFilename());
         }
-        return path15.join(basePath, this.getFilename());
+        return path16.join(basePath, this.getFilename());
       }
       /**
        * Load data from disk (with caching)
@@ -6042,7 +6301,7 @@ var init_memory_system = __esm({
         }
         const filePath = this.getPath(projectId);
         try {
-          const content = await fs16.readFile(filePath, "utf-8");
+          const content = await fs17.readFile(filePath, "utf-8");
           this._data = JSON.parse(content);
           this.afterLoad(this._data);
         } catch (error) {
@@ -6068,8 +6327,8 @@ var init_memory_system = __esm({
       async save(projectId) {
         if (!this._data) return;
         const filePath = this.getPath(projectId);
-        await fs16.mkdir(path15.dirname(filePath), { recursive: true });
-        await fs16.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
+        await fs17.mkdir(path16.dirname(filePath), { recursive: true });
+        await fs17.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
       }
       /**
        * Get cached data without loading (may be null)
@@ -6135,11 +6394,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 path15.join(path_manager_default.getGlobalProjectPath(projectId), "memory", "sessions", yearMonth, `${day}.jsonl`);
+        return path16.join(path_manager_default.getGlobalProjectPath(projectId), "memory", "sessions", yearMonth, `${day}.jsonl`);
       }
       async appendHistory(projectId, entry) {
         const sessionPath = this._getSessionPath(projectId);
-        await ensureDir(path15.dirname(sessionPath));
+        await ensureDir(path16.dirname(sessionPath));
         const logEntry = {
           ts: getTimestamp(),
           ...entry,
@@ -6608,9 +6867,9 @@ Context: ${context}` : ""}`,
 });
 
 // core/agentic/ground-truth.ts
-import fs17 from "fs/promises";
-import path16 from "path";
-import os6 from "os";
+import fs18 from "fs/promises";
+import path17 from "path";
+import os7 from "os";
 import { execSync as execSync2 } from "child_process";
 function formatDuration2(ms) {
   const hours = Math.floor(ms / (1e3 * 60 * 60));
@@ -6647,7 +6906,7 @@ async function verifyDone(context) {
   const actual = {};
   const nowPath = context.paths.now;
   try {
-    const nowContent = await fs17.readFile(nowPath, "utf-8");
+    const nowContent = await fs18.readFile(nowPath, "utf-8");
     actual.nowExists = true;
     actual.nowContent = nowContent.trim();
     actual.nowLength = nowContent.length;
@@ -6671,7 +6930,7 @@ async function verifyDone(context) {
   }
   const nextPath = context.paths.next;
   try {
-    const nextContent = await fs17.readFile(nextPath, "utf-8");
+    const nextContent = await fs18.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[ \]/g) || [];
     actual.pendingTasks = tasks.length;
@@ -6681,7 +6940,7 @@ async function verifyDone(context) {
   }
   const metricsPath = context.paths.metrics;
   try {
-    await fs17.access(path16.dirname(metricsPath), fs17.constants.W_OK);
+    await fs18.access(path17.dirname(metricsPath), fs18.constants.W_OK);
     actual.metricsWritable = true;
   } catch {
     actual.metricsWritable = false;
@@ -6712,9 +6971,9 @@ async function verifyShip(context) {
   } catch {
     actual.gitAvailable = false;
   }
-  const pkgPath = path16.join(context.projectPath, "package.json");
+  const pkgPath = path17.join(context.projectPath, "package.json");
   try {
-    const pkgContent = await fs17.readFile(pkgPath, "utf-8");
+    const pkgContent = await fs18.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     actual.currentVersion = pkg.version;
     actual.hasPackageJson = true;
@@ -6723,7 +6982,7 @@ async function verifyShip(context) {
   }
   const shippedPath = context.paths.shipped;
   try {
-    const shippedContent = await fs17.readFile(shippedPath, "utf-8");
+    const shippedContent = await fs18.readFile(shippedPath, "utf-8");
     actual.shippedExists = true;
     const featureName = context.params.feature || context.params.description;
     if (featureName) {
@@ -6739,7 +6998,7 @@ async function verifyShip(context) {
   }
   if (actual.hasPackageJson) {
     try {
-      const pkgContent = await fs17.readFile(pkgPath, "utf-8");
+      const pkgContent = await fs18.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       actual.hasTestScript = !!pkg.scripts?.test;
     } catch {
@@ -6759,7 +7018,7 @@ async function verifyFeature(context) {
   const actual = {};
   const nextPath = context.paths.next;
   try {
-    const nextContent = await fs17.readFile(nextPath, "utf-8");
+    const nextContent = await fs18.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[[ x]\]/g) || [];
     actual.taskCount = tasks.length;
@@ -6774,7 +7033,7 @@ async function verifyFeature(context) {
   }
   const roadmapPath = context.paths.roadmap;
   try {
-    const roadmapContent = await fs17.readFile(roadmapPath, "utf-8");
+    const roadmapContent = await fs18.readFile(roadmapPath, "utf-8");
     actual.roadmapExists = true;
     const featureName = context.params.description || context.params.feature;
     if (featureName) {
@@ -6789,7 +7048,7 @@ async function verifyFeature(context) {
   }
   const nowPath = context.paths.now;
   try {
-    const nowContent = await fs17.readFile(nowPath, "utf-8");
+    const nowContent = await fs18.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");
@@ -6810,7 +7069,7 @@ async function verifyNow(context) {
   const actual = {};
   const nowPath = context.paths.now;
   try {
-    const nowContent = await fs17.readFile(nowPath, "utf-8");
+    const nowContent = await fs18.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);
@@ -6826,7 +7085,7 @@ async function verifyNow(context) {
   }
   const nextPath = context.paths.next;
   try {
-    const nextContent = await fs17.readFile(nextPath, "utf-8");
+    const nextContent = await fs18.readFile(nextPath, "utf-8");
     const pendingTasks = (nextContent.match(/- \[ \]/g) || []).length;
     actual.pendingTasks = pendingTasks;
     if (!context.params.task && pendingTasks > 0) {
@@ -6846,9 +7105,9 @@ async function verifyInit(context) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path16.join(context.projectPath, ".prjct/prjct.config.json");
+  const configPath = path17.join(context.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs17.readFile(configPath, "utf-8");
+    const configContent = await fs18.readFile(configPath, "utf-8");
     actual.alreadyInitialized = true;
     actual.existingConfig = JSON.parse(configContent);
     warnings.push("Project already initialized");
@@ -6856,13 +7115,13 @@ async function verifyInit(context) {
   } catch {
     actual.alreadyInitialized = false;
   }
-  const globalPath = path16.join(os6.homedir(), ".prjct-cli");
+  const globalPath = path17.join(os7.homedir(), ".prjct-cli");
   try {
-    await fs17.access(globalPath, fs17.constants.W_OK);
+    await fs18.access(globalPath, fs18.constants.W_OK);
     actual.globalPathWritable = true;
   } catch {
     try {
-      await fs17.mkdir(globalPath, { recursive: true });
+      await fs18.mkdir(globalPath, { recursive: true });
       actual.globalPathWritable = true;
       actual.globalPathCreated = true;
     } catch {
@@ -6882,9 +7141,9 @@ async function verifySync(context) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path16.join(context.projectPath, ".prjct/prjct.config.json");
+  const configPath = path17.join(context.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs17.readFile(configPath, "utf-8");
+    const configContent = await fs18.readFile(configPath, "utf-8");
     actual.hasConfig = true;
     actual.config = JSON.parse(configContent);
   } catch {
@@ -6894,9 +7153,9 @@ async function verifySync(context) {
     return { verified: false, actual, warnings, recommendations };
   }
   const projectId = actual.config?.projectId;
-  const globalProjectPath = path16.join(os6.homedir(), ".prjct-cli/projects", projectId || "");
+  const globalProjectPath = path17.join(os7.homedir(), ".prjct-cli/projects", projectId || "");
   try {
-    await fs17.access(globalProjectPath);
+    await fs18.access(globalProjectPath);
     actual.globalStorageExists = true;
   } catch {
     actual.globalStorageExists = false;
@@ -6918,7 +7177,7 @@ async function verifyAnalyze(context) {
   actual.detectedFiles = [];
   for (const file of files) {
     try {
-      await fs17.access(path16.join(context.projectPath, file));
+      await fs18.access(path17.join(context.projectPath, file));
       actual.detectedFiles.push(file);
     } catch {
     }
@@ -6931,7 +7190,7 @@ async function verifyAnalyze(context) {
   actual.detectedSrcDirs = [];
   for (const dir of srcDirs) {
     try {
-      const stat = await fs17.stat(path16.join(context.projectPath, dir));
+      const stat = await fs18.stat(path17.join(context.projectPath, dir));
       if (stat.isDirectory()) {
         ;
         actual.detectedSrcDirs.push(dir);
@@ -6953,9 +7212,9 @@ async function verifySpec(context) {
   const actual = {};
   const specsPath = context.paths.specs;
   try {
-    await fs17.access(specsPath);
+    await fs18.access(specsPath);
     actual.specsExists = true;
-    const files = await fs17.readdir(specsPath);
+    const files = await fs18.readdir(specsPath);
     actual.existingSpecs = files.filter((f) => f.endsWith(".md"));
     actual.specCount = actual.existingSpecs.length;
   } catch {
@@ -7486,150 +7745,31 @@ var init_plan_mode = __esm({
   }
 });
 
-// core/agentic/agent-router.ts
-import fs18 from "fs/promises";
-import path17 from "path";
-var AgentRouter, agent_router_default;
-var init_agent_router = __esm({
-  "core/agentic/agent-router.ts"() {
-    "use strict";
-    init_config_manager();
-    init_path_manager();
-    AgentRouter = class {
-      static {
-        __name(this, "AgentRouter");
-      }
-      projectId = null;
-      projectPath = null;
-      agentsPath = null;
-      /**
-       * Initialize router with project context
-       */
-      async initialize(projectPath) {
-        this.projectId = await config_manager_default.getProjectId(projectPath);
-        this.projectPath = projectPath;
-        this.agentsPath = path_manager_default.getFilePath(this.projectId, "agents", "");
-      }
-      /**
-       * Load all available agents from global storage
-       */
-      async loadAvailableAgents() {
-        if (!this.agentsPath) return [];
-        try {
-          const files = await fs18.readdir(this.agentsPath);
-          const agents = [];
-          for (const file of files) {
-            if (file.endsWith(".md")) {
-              const name = file.replace(".md", "");
-              const content = await fs18.readFile(path17.join(this.agentsPath, file), "utf-8");
-              agents.push({ name, content });
-            }
-          }
-          return agents;
-        } catch {
-          return [];
-        }
-      }
-      /**
-       * Get list of available agent names
-       */
-      async getAgentNames() {
-        const agents = await this.loadAvailableAgents();
-        return agents.map((a) => a.name);
-      }
-      /**
-       * Load a specific agent by name from global storage
-       */
-      async loadAgent(name) {
-        if (!this.agentsPath) return null;
-        try {
-          const filePath = path17.join(this.agentsPath, `${name}.md`);
-          const content = await fs18.readFile(filePath, "utf-8");
-          return { name, content };
-        } catch {
-          return null;
-        }
-      }
-      /**
-       * Build context for Claude to decide agent assignment
-       */
-      async buildAssignmentContext(task, projectPath) {
-        const agents = await this.getAgentNames();
-        return {
-          task: typeof task === "string" ? task : task.description || "",
-          availableAgents: agents,
-          projectPath,
-          projectId: this.projectId,
-          // Claude reads this and decides via template
-          _template: "templates/agent-assignment.md"
-        };
-      }
-      /**
-       * Load multiple agents by @ mention names
-       * @example loadAgentsByMention(["frontend", "uxui"]) -> [Agent, Agent]
-       */
-      async loadAgentsByMention(mentions) {
-        const agents = [];
-        for (const name of mentions) {
-          const agent = await this.loadAgent(name);
-          if (agent) {
-            agents.push(agent);
-          }
-        }
-        return agents;
-      }
-      /**
-       * Log agent usage to JSONL file
-       */
-      async logUsage(task, agent, _projectPath) {
-        try {
-          const logPath = path17.join(
-            process.env.HOME || "",
-            ".prjct-cli",
-            "projects",
-            this.projectId || "",
-            "agent-usage.jsonl"
-          );
-          const entry = JSON.stringify({
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            task: typeof task === "string" ? task : task.description,
-            agent: typeof agent === "string" ? agent : agent.name,
-            projectId: this.projectId
-          }) + "\n";
-          await fs18.appendFile(logPath, entry);
-        } catch {
-        }
-      }
-    };
-    agent_router_default = AgentRouter;
-  }
-});
-
-// core/agentic/command-executor.ts
-import fs19 from "fs";
-import path18 from "path";
-import os7 from "os";
-function signalStart(commandName) {
-  try {
-    const dir = path18.dirname(RUNNING_FILE);
-    if (!fs19.existsSync(dir)) {
-      fs19.mkdirSync(dir, { recursive: true });
-    }
-    fs19.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
-  } catch {
-  }
-}
-function signalEnd() {
-  try {
-    if (fs19.existsSync(RUNNING_FILE)) {
-      fs19.unlinkSync(RUNNING_FILE);
-    }
-  } catch {
-  }
-}
-var RUNNING_FILE, CommandExecutor, commandExecutor, command_executor_default;
-var init_command_executor = __esm({
-  "core/agentic/command-executor.ts"() {
+// core/agentic/command-executor.ts
+import fs19 from "fs";
+import path18 from "path";
+import os8 from "os";
+function signalStart(commandName) {
+  try {
+    const dir = path18.dirname(RUNNING_FILE);
+    if (!fs19.existsSync(dir)) {
+      fs19.mkdirSync(dir, { recursive: true });
+    }
+    fs19.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
+  } catch {
+  }
+}
+function signalEnd() {
+  try {
+    if (fs19.existsSync(RUNNING_FILE)) {
+      fs19.unlinkSync(RUNNING_FILE);
+    }
+  } catch {
+  }
+}
+var RUNNING_FILE, CommandExecutor, commandExecutor, command_executor_default;
+var init_command_executor = __esm({
+  "core/agentic/command-executor.ts"() {
     "use strict";
     init_template_loader();
     init_context_builder();
@@ -7640,8 +7780,7 @@ var init_command_executor = __esm({
     init_memory_system();
     init_ground_truth();
     init_plan_mode();
-    init_agent_router();
-    RUNNING_FILE = path18.join(os7.homedir(), ".prjct-cli", ".running");
+    RUNNING_FILE = path18.join(os8.homedir(), ".prjct-cli", ".running");
     __name(signalStart, "signalStart");
     __name(signalEnd, "signalEnd");
     CommandExecutor = class {
@@ -7678,14 +7817,6 @@ var init_command_executor = __esm({
           };
         }
         try {
-          const taskInput = params.task || params.description || "";
-          const { prjctAgents, claudeSubagents, cleanInput } = prompt_builder_default.parseAgentMentions(taskInput);
-          if (prjctAgents.length > 0 || claudeSubagents.length > 0) {
-            if (params.task) params.task = cleanInput;
-            if (params.description) params.description = cleanInput;
-            params._mentionedAgents = prjctAgents;
-            params._claudeSubagents = claudeSubagents;
-          }
           const template = await template_loader_default.load(commandName);
           const metadataContext = await context_builder_default.build(projectPath, params);
           const requiresPlanning = plan_mode_default.requiresPlanning(commandName);
@@ -7725,7 +7856,7 @@ var init_command_executor = __esm({
           let context = metadataContext;
           context = {
             ...context,
-            agentsPath: path18.join(os7.homedir(), ".prjct-cli", "projects", metadataContext.projectId || "", "agents"),
+            agentsPath: path18.join(os8.homedir(), ".prjct-cli", "projects", metadataContext.projectId || "", "agents"),
             agentRoutingPath: path18.join(__dirname, "..", "..", "templates", "agentic", "agent-routing.md"),
             agenticDelegation: true
           };
@@ -7748,50 +7879,23 @@ var init_command_executor = __esm({
               5
             );
           }
-          let primaryAgent = null;
-          if (prjctAgents.length > 0) {
-            const agentRouter = new agent_router_default();
-            await agentRouter.initialize(projectPath);
-            const loadedAgents = await agentRouter.loadAgentsByMention(prjctAgents);
-            if (loadedAgents.length > 0) {
-              primaryAgent = {
-                name: loadedAgents[0].name,
-                content: loadedAgents[0].content,
-                role: void 0,
-                skills: []
-              };
-              console.log(`\u{1F916} Loading agents: ${loadedAgents.map((a) => `@${a.name}`).join(", ")}`);
-            }
-          }
           const planInfo = {
             isPlanning: requiresPlanning || isInPlanningMode,
             requiresApproval: isDestructive && !params.approved,
             active: activePlan,
             allowedTools: plan_mode_default.getAllowedTools(isInPlanningMode, template.frontmatter["allowed-tools"] || [])
           };
-          let prompt = prompt_builder_default.build(
+          const prompt = prompt_builder_default.build(
             template,
             context,
             state,
-            primaryAgent,
+            null,
             learnedPatterns,
             null,
             relevantMemories,
             planInfo
           );
-          if (claudeSubagents.length > 0) {
-            const subagentInstructions = prompt_builder_default.buildSubagentInstructions(claudeSubagents);
-            prompt = prompt + subagentInstructions;
-            console.log(`\u{1F527} Claude subagents requested: ${claudeSubagents.map((s) => `@${s}`).join(", ")}`);
-          }
-          const toolPermissions = template.frontmatter["tool-permissions"];
-          if (toolPermissions) {
-            const permissionsSection = prompt_builder_default.buildToolPermissions(toolPermissions);
-            prompt = prompt + permissionsSection;
-          }
-          if (!primaryAgent) {
-            console.log(`\u{1F916} Agentic delegation enabled - Claude will assign agent via Task tool`);
-          }
+          console.log(`\u{1F916} Agentic delegation enabled - Claude will assign agent via Task tool`);
           loop_detector_default.recordSuccess(commandName, loopContext);
           this.signalEnd();
           return {
@@ -7917,7 +8021,7 @@ var init_command_executor = __esm({
 import https from "https";
 import fs20 from "fs";
 import path19 from "path";
-import os8 from "os";
+import os9 from "os";
 import chalk from "chalk";
 var UpdateChecker, update_checker_default;
 var init_update_checker = __esm({
@@ -7933,7 +8037,7 @@ var init_update_checker = __esm({
       checkInterval;
       constructor() {
         this.packageName = "prjct-cli";
-        this.cacheDir = path19.join(os8.homedir(), ".prjct-cli", "config");
+        this.cacheDir = path19.join(os9.homedir(), ".prjct-cli", "config");
         this.cacheFile = path19.join(this.cacheDir, "update-cache.json");
         this.checkInterval = 24 * 60 * 60 * 1e3;
       }
@@ -8311,6 +8415,111 @@ var init_agent_detector = __esm({
   }
 });
 
+// core/agentic/agent-router.ts
+import fs22 from "fs/promises";
+import path21 from "path";
+var AgentRouter, agent_router_default;
+var init_agent_router = __esm({
+  "core/agentic/agent-router.ts"() {
+    "use strict";
+    init_config_manager();
+    init_path_manager();
+    AgentRouter = class {
+      static {
+        __name(this, "AgentRouter");
+      }
+      projectId = null;
+      projectPath = null;
+      agentsPath = null;
+      /**
+       * Initialize router with project context
+       */
+      async initialize(projectPath) {
+        this.projectId = await config_manager_default.getProjectId(projectPath);
+        this.projectPath = projectPath;
+        this.agentsPath = path_manager_default.getFilePath(this.projectId, "agents", "");
+      }
+      /**
+       * Load all available agents from global storage
+       */
+      async loadAvailableAgents() {
+        if (!this.agentsPath) return [];
+        try {
+          const files = await fs22.readdir(this.agentsPath);
+          const agents = [];
+          for (const file of files) {
+            if (file.endsWith(".md")) {
+              const name = file.replace(".md", "");
+              const content = await fs22.readFile(path21.join(this.agentsPath, file), "utf-8");
+              agents.push({ name, content });
+            }
+          }
+          return agents;
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Get list of available agent names
+       */
+      async getAgentNames() {
+        const agents = await this.loadAvailableAgents();
+        return agents.map((a) => a.name);
+      }
+      /**
+       * Load a specific agent by name from global storage
+       */
+      async loadAgent(name) {
+        if (!this.agentsPath) return null;
+        try {
+          const filePath = path21.join(this.agentsPath, `${name}.md`);
+          const content = await fs22.readFile(filePath, "utf-8");
+          return { name, content };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Build context for Claude to decide agent assignment
+       */
+      async buildAssignmentContext(task, projectPath) {
+        const agents = await this.getAgentNames();
+        return {
+          task: typeof task === "string" ? task : task.description || "",
+          availableAgents: agents,
+          projectPath,
+          projectId: this.projectId,
+          // Claude reads this and decides via template
+          _template: "templates/agent-assignment.md"
+        };
+      }
+      /**
+       * Log agent usage to JSONL file
+       */
+      async logUsage(task, agent, _projectPath) {
+        try {
+          const logPath = path21.join(
+            process.env.HOME || "",
+            ".prjct-cli",
+            "projects",
+            this.projectId || "",
+            "agent-usage.jsonl"
+          );
+          const entry = JSON.stringify({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            task: typeof task === "string" ? task : task.description,
+            agent: typeof agent === "string" ? agent : agent.name,
+            projectId: this.projectId
+          }) + "\n";
+          await fs22.appendFile(logPath, entry);
+        } catch {
+        }
+      }
+    };
+    agent_router_default = AgentRouter;
+  }
+});
+
 // import("../infrastructure/**/*-agent") in core/services/agent-service.ts
 var globImport_infrastructure_agent;
 var init_ = __esm({
@@ -8453,8 +8662,8 @@ var init_agent_service = __esm({
 });
 
 // core/domain/analyzer.ts
-import fs22 from "fs/promises";
-import path21 from "path";
+import fs23 from "fs/promises";
+import path22 from "path";
 import { promisify as promisify3 } from "util";
 import { exec as execCallback2 } from "child_process";
 var exec3, CodebaseAnalyzer, analyzer, analyzer_default2;
@@ -8478,8 +8687,8 @@ var init_analyzer2 = __esm({
        */
       async readPackageJson() {
         try {
-          const packagePath = path21.join(this.projectPath, "package.json");
-          const content = await fs22.readFile(packagePath, "utf-8");
+          const packagePath = path22.join(this.projectPath, "package.json");
+          const content = await fs23.readFile(packagePath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -8490,8 +8699,8 @@ var init_analyzer2 = __esm({
        */
       async readCargoToml() {
         try {
-          const cargoPath = path21.join(this.projectPath, "Cargo.toml");
-          return await fs22.readFile(cargoPath, "utf-8");
+          const cargoPath = path22.join(this.projectPath, "Cargo.toml");
+          return await fs23.readFile(cargoPath, "utf-8");
         } catch {
           return null;
         }
@@ -8501,8 +8710,8 @@ var init_analyzer2 = __esm({
        */
       async readRequirements() {
         try {
-          const reqPath = path21.join(this.projectPath, "requirements.txt");
-          return await fs22.readFile(reqPath, "utf-8");
+          const reqPath = path22.join(this.projectPath, "requirements.txt");
+          return await fs23.readFile(reqPath, "utf-8");
         } catch {
           return null;
         }
@@ -8512,8 +8721,8 @@ var init_analyzer2 = __esm({
        */
       async readGoMod() {
         try {
-          const goModPath = path21.join(this.projectPath, "go.mod");
-          return await fs22.readFile(goModPath, "utf-8");
+          const goModPath = path22.join(this.projectPath, "go.mod");
+          return await fs23.readFile(goModPath, "utf-8");
         } catch {
           return null;
         }
@@ -8523,8 +8732,8 @@ var init_analyzer2 = __esm({
        */
       async readGemfile() {
         try {
-          const gemfilePath = path21.join(this.projectPath, "Gemfile");
-          return await fs22.readFile(gemfilePath, "utf-8");
+          const gemfilePath = path22.join(this.projectPath, "Gemfile");
+          return await fs23.readFile(gemfilePath, "utf-8");
         } catch {
           return null;
         }
@@ -8534,8 +8743,8 @@ var init_analyzer2 = __esm({
        */
       async readMixExs() {
         try {
-          const mixPath = path21.join(this.projectPath, "mix.exs");
-          return await fs22.readFile(mixPath, "utf-8");
+          const mixPath = path22.join(this.projectPath, "mix.exs");
+          return await fs23.readFile(mixPath, "utf-8");
         } catch {
           return null;
         }
@@ -8545,8 +8754,8 @@ var init_analyzer2 = __esm({
        */
       async readPomXml() {
         try {
-          const pomPath = path21.join(this.projectPath, "pom.xml");
-          return await fs22.readFile(pomPath, "utf-8");
+          const pomPath = path22.join(this.projectPath, "pom.xml");
+          return await fs23.readFile(pomPath, "utf-8");
         } catch {
           return null;
         }
@@ -8556,8 +8765,8 @@ var init_analyzer2 = __esm({
        */
       async readComposerJson() {
         try {
-          const composerPath = path21.join(this.projectPath, "composer.json");
-          const content = await fs22.readFile(composerPath, "utf-8");
+          const composerPath = path22.join(this.projectPath, "composer.json");
+          const content = await fs23.readFile(composerPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -8568,8 +8777,8 @@ var init_analyzer2 = __esm({
        */
       async readPyprojectToml() {
         try {
-          const pyprojectPath = path21.join(this.projectPath, "pyproject.toml");
-          return await fs22.readFile(pyprojectPath, "utf-8");
+          const pyprojectPath = path22.join(this.projectPath, "pyproject.toml");
+          return await fs23.readFile(pyprojectPath, "utf-8");
         } catch {
           return null;
         }
@@ -8602,7 +8811,7 @@ var init_analyzer2 = __esm({
        */
       async listConfigFiles() {
         try {
-          const entries = await fs22.readdir(this.projectPath);
+          const entries = await fs23.readdir(this.projectPath);
           const configPatterns = [
             /^package\.json$/,
             /^Cargo\.toml$/,
@@ -8629,7 +8838,7 @@ var init_analyzer2 = __esm({
        */
       async listDirectories() {
         try {
-          const entries = await fs22.readdir(this.projectPath, { withFileTypes: true });
+          const entries = await fs23.readdir(this.projectPath, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
         } catch {
           return [];
@@ -8694,7 +8903,7 @@ var init_analyzer2 = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs22.access(path21.join(this.projectPath, filename));
+          await fs23.access(path22.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -8705,8 +8914,8 @@ var init_analyzer2 = __esm({
        */
       async readFile(relativePath) {
         try {
-          const fullPath = path21.join(this.projectPath, relativePath);
-          return await fs22.readFile(fullPath, "utf-8");
+          const fullPath = path22.join(this.projectPath, relativePath);
+          return await fs23.readFile(fullPath, "utf-8");
         } catch {
           return null;
         }
@@ -8732,16 +8941,16 @@ var init_analyzer2 = __esm({
 });
 
 // core/context/generator.ts
-import fs23 from "fs/promises";
-import path22 from "path";
-import os9 from "os";
+import fs24 from "fs/promises";
+import path23 from "path";
+import os10 from "os";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
 async function generateContext(projectId, repoPath) {
-  const globalPath = path22.join(os9.homedir(), ".prjct-cli/projects", projectId);
-  const contextPath = path22.join(globalPath, "context");
+  const globalPath = path23.join(os10.homedir(), ".prjct-cli/projects", projectId);
+  const contextPath = path23.join(globalPath, "context");
   const storage = getStorage(projectId);
-  await fs23.mkdir(contextPath, { recursive: true });
+  await fs24.mkdir(contextPath, { recursive: true });
   const project = await storage.read(["project"]) || {};
   const taskPaths = await storage.list(["task"]);
   const featurePaths = await storage.list(["feature"]);
@@ -8807,8 +9016,8 @@ async function getPackageData(repoPath) {
     scripts: {}
   };
   try {
-    const pkgPath = path22.join(repoPath, "package.json");
-    const pkg = JSON.parse(await fs23.readFile(pkgPath, "utf-8"));
+    const pkgPath = path23.join(repoPath, "package.json");
+    const pkg = JSON.parse(await fs24.readFile(pkgPath, "utf-8"));
     data.dependencies = pkg.dependencies || {};
     data.devDependencies = pkg.devDependencies || {};
     data.scripts = pkg.scripts || {};
@@ -8817,7 +9026,7 @@ async function getPackageData(repoPath) {
   return data;
 }
 async function generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath) {
-  const projectName = project.name || path22.basename(repoPath);
+  const projectName = project.name || path23.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");
@@ -8892,7 +9101,7 @@ ${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || "Specialis
     \u2514\u2500\u2500 pending.json
 \`\`\`
 `;
-  await fs23.writeFile(path22.join(contextPath, "CLAUDE.md"), content, "utf-8");
+  await fs24.writeFile(path23.join(contextPath, "CLAUDE.md"), content, "utf-8");
 }
 async function generateNowMd(contextPath, tasks) {
   const currentTask = tasks.find((t) => t.status === "in_progress");
@@ -8907,7 +9116,7 @@ async function generateNowMd(contextPath, tasks) {
 
 _No active task. Use /p:now to start._
 `;
-  await fs23.writeFile(path22.join(contextPath, "now.md"), content, "utf-8");
+  await fs24.writeFile(path23.join(contextPath, "now.md"), content, "utf-8");
 }
 async function generateQueueMd(contextPath, tasks) {
   const pendingTasks = tasks.filter((t) => t.status === "pending");
@@ -8915,7 +9124,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 fs23.writeFile(path22.join(contextPath, "queue.md"), content, "utf-8");
+  await fs24.writeFile(path23.join(contextPath, "queue.md"), content, "utf-8");
 }
 async function generateSummaryMd(contextPath, project, gitData, pkgData) {
   const content = `# PROJECT SUMMARY
@@ -8935,7 +9144,7 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 - Production: ${Object.keys(pkgData.dependencies).length}
 - Dev: ${Object.keys(pkgData.devDependencies).length}
 `;
-  await fs23.writeFile(path22.join(contextPath, "summary.md"), content, "utf-8");
+  await fs24.writeFile(path23.join(contextPath, "summary.md"), content, "utf-8");
 }
 var execAsync2;
 var init_generator = __esm({
@@ -8958,7 +9167,7 @@ var analysis_exports = {};
 __export(analysis_exports, {
   AnalysisCommands: () => AnalysisCommands
 });
-import path23 from "path";
+import path24 from "path";
 var AnalysisCommands;
 var init_analysis2 = __esm({
   "core/commands/analysis.ts"() {
@@ -9038,7 +9247,7 @@ var init_analysis2 = __esm({
         lines.push("# Repository Analysis\n");
         lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
 `);
-        const projectName = path23.basename(projectPath);
+        const projectName = path24.basename(projectPath);
         lines.push(`## Project: ${projectName}
 `);
         lines.push("## Stack Detected\n");
@@ -9162,7 +9371,7 @@ var planning_exports = {};
 __export(planning_exports, {
   PlanningCommands: () => PlanningCommands
 });
-import path24 from "path";
+import path25 from "path";
 async function getAnalysisCommands() {
   if (!_analysisCommands) {
     const { AnalysisCommands: AnalysisCommands2 } = await Promise.resolve().then(() => (init_analysis2(), analysis_exports));
@@ -9227,7 +9436,7 @@ var init_planning = __esm({
             }, null, 2)
           };
           for (const [filePath, content] of Object.entries(baseFiles)) {
-            await tool_registry_default.get("Write")(path24.join(globalPath, filePath), content);
+            await tool_registry_default.get("Write")(path25.join(globalPath, filePath), content);
           }
           const isEmpty = await this._detectEmptyDirectory(projectPath);
           const hasCode = await this._detectExistingCode(projectPath);
@@ -9248,7 +9457,7 @@ var init_planning = __esm({
               return { success: true, mode: "blank_no_idea", projectId };
             }
             output_default.spin("architect mode...");
-            const sessionPath = path24.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path25.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -9390,7 +9599,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 = path24.join(globalPath, "planning", "architect-session.md");
+          const planPath = path25.join(globalPath, "planning", "architect-session.md");
           let planContent;
           try {
             planContent = await file_helper_exports.readFile(planPath);
@@ -9464,7 +9673,7 @@ ${steps}`);
           if (isComplex) {
             output_default.spin("analyzing idea...");
             const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-            const sessionPath = path24.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path25.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -9519,10 +9728,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!featureName) {
             output_default.spin("loading specs...");
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
-            const specsPath2 = path24.join(globalPath2, "planning", "specs");
+            const specsPath2 = path25.join(globalPath2, "planning", "specs");
             try {
-              const fs25 = await import("fs/promises");
-              const files = await fs25.readdir(specsPath2);
+              const fs26 = await import("fs/promises");
+              const files = await fs26.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -9544,10 +9753,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           }
           output_default.spin("creating spec...");
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-          const specsPath = path24.join(globalPath, "planning", "specs");
+          const specsPath = path25.join(globalPath, "planning", "specs");
           await file_helper_exports.ensureDir(specsPath);
           const slug = featureName.toLowerCase().replace(/\s+/g, "-");
-          const specFile = path24.join(specsPath, `${slug}.md`);
+          const specFile = path25.join(specsPath, `${slug}.md`);
           const specContent = `# Specification: ${featureName}
 
 ## Overview
@@ -10159,18 +10368,18 @@ var init_workflow = __esm({
 });
 
 // core/utils/project-commands.ts
-import path25 from "path";
+import path26 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(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";
+  if (await fileExists(path26.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path26.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path26.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path26.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path26.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -10186,7 +10395,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path25.join(projectPath, "package.json");
+  const pkgPath = path26.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -10203,27 +10412,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path25.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path26.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path25.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path26.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path25.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path26.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path25.join(projectPath, "go.mod"))) {
+  if (await fileExists(path26.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(path25.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path26.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path25.join(projectPath, "gradlew")) && (await fileExists(path25.join(projectPath, "build.gradle")) || await fileExists(path25.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path26.join(projectPath, "gradlew")) && (await fileExists(path26.join(projectPath, "build.gradle")) || await fileExists(path26.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -10240,7 +10449,7 @@ var init_project_commands = __esm({
 });
 
 // core/commands/shipping.ts
-import path26 from "path";
+import path27 from "path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -10362,7 +10571,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path26.join(projectPath, "package.json");
+          const pkgPath = path27.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);
@@ -10381,7 +10590,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path26.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path27.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())}
 
@@ -10722,6 +10931,36 @@ var init_registry = __esm({
           error: `Command not found: ${name}`
         };
       }
+      /**
+       * Execute without requiring project (for init, setup commands)
+       * @deprecated Use execute() - it auto-detects based on command metadata
+       */
+      async executeWithoutProject(name, params, projectPath = process.cwd()) {
+        const handler = this.handlers.get(name);
+        if (handler) {
+          const context = {
+            projectId: "",
+            projectPath,
+            globalPath: "",
+            timestamp: getTimestamp()
+          };
+          return handler.execute(params, context);
+        }
+        const handlerFn = this.handlerFns.get(name);
+        if (handlerFn) {
+          const context = {
+            projectId: "",
+            projectPath,
+            globalPath: "",
+            timestamp: getTimestamp()
+          };
+          return handlerFn(params, context);
+        }
+        return {
+          success: false,
+          error: `Command not found: ${name}`
+        };
+      }
       /**
        * Clear all registrations (useful for testing)
        */
@@ -10737,7 +10976,7 @@ var init_registry = __esm({
 });
 
 // core/commands/analytics.ts
-import path27 from "path";
+import path28 from "path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -10762,7 +11001,7 @@ var init_analytics = __esm({
             output_default.fail("no project ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path27.basename(projectPath);
+          const projectName = path28.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -11000,7 +11239,7 @@ ${catInfo?.title || cat}:`);
 });
 
 // core/commands/cleanup.ts
-import path28 from "path";
+import path29 from "path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -11016,7 +11255,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path28.basename(filePath));
+          results.rotated.push(path29.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -11107,7 +11346,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path29 from "path";
+import path30 from "path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -11119,7 +11358,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 = path29.join(
+    const designsPath = path30.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -11159,7 +11398,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path29.join(designsPath, designFileName);
+    const designFilePath = path30.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -11183,7 +11422,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path30 from "path";
+import path31 from "path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -11231,7 +11470,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path30.join(
+    const snapshotsPath = path31.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
@@ -11252,7 +11491,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path30.join(snapshotsPath, "history.json");
+      const snapshotFile = path31.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -11289,11 +11528,11 @@ async function redo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path30.join(
+    const snapshotsPath = path31.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path30.join(snapshotsPath, "history.json");
+    const snapshotFile = path31.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -11349,11 +11588,11 @@ async function history(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path30.join(
+    const snapshotsPath = path31.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path30.join(snapshotsPath, "history.json");
+    const snapshotFile = path31.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -11455,9 +11694,9 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import path31 from "path";
-import fs24 from "fs";
-import os10 from "os";
+import path32 from "path";
+import fs25 from "fs";
+import os11 from "os";
 import chalk4 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -11564,9 +11803,9 @@ var init_setup2 = __esm({
        */
       async installStatusLine() {
         try {
-          const claudeDir = path31.join(os10.homedir(), ".claude");
-          const settingsPath = path31.join(claudeDir, "settings.json");
-          const statusLinePath = path31.join(claudeDir, "prjct-statusline.sh");
+          const claudeDir = path32.join(os11.homedir(), ".claude");
+          const settingsPath = path32.join(claudeDir, "settings.json");
+          const statusLinePath = path32.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -11624,11 +11863,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs24.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs25.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs24.existsSync(settingsPath)) {
+          if (fs25.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs24.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs25.readFileSync(settingsPath, "utf8"));
             } catch {
             }
           }
@@ -11636,7 +11875,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs24.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs25.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -11741,6 +11980,9 @@ var init_commands = __esm({
         this.prjctDir = ".prjct";
       }
       // ========== Workflow Commands ==========
+      async work(task = null, projectPath = process.cwd()) {
+        return this.workflow.now(task, projectPath);
+      }
       async done(projectPath = process.cwd()) {
         return this.workflow.done(projectPath);
       }
@@ -11757,6 +11999,9 @@ var init_commands = __esm({
       async init(idea = null, projectPath = process.cwd()) {
         return this.planning.init(idea, projectPath);
       }
+      async feature(description, projectPath = process.cwd()) {
+        return this.planning.feature(description, projectPath);
+      }
       async bug(description, projectPath = process.cwd()) {
         return this.planning.bug(description, projectPath);
       }
@@ -11897,6 +12142,17 @@ var init_command_data = __esm({
         requiresProject: true,
         features: ["Agentic type classification", "7-phase workflow", "Git branch management", "Task breakdown"]
       },
+      {
+        name: "feature",
+        group: "core",
+        description: "DEPRECATED - Use /p:task instead",
+        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+        params: "<description>",
+        implemented: true,
+        hasTemplate: true,
+        requiresProject: true,
+        deprecated: true
+      },
       {
         name: "spec",
         group: "core",
@@ -11907,6 +12163,28 @@ var init_command_data = __esm({
         hasTemplate: true,
         requiresProject: true
       },
+      {
+        name: "now",
+        group: "core",
+        description: "DEPRECATED - Use /p:task instead",
+        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+        params: "[task]",
+        implemented: true,
+        hasTemplate: true,
+        requiresProject: true,
+        deprecated: true
+      },
+      {
+        name: "work",
+        group: "core",
+        description: "DEPRECATED - Use /p:task instead",
+        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+        params: "[task]",
+        implemented: true,
+        hasTemplate: true,
+        requiresProject: true,
+        deprecated: true
+      },
       {
         name: "pause",
         group: "core",
@@ -12221,7 +12499,7 @@ var init_commands2 = __esm({
     init_commands();
     init_registry();
     init_register();
-    init_types();
+    init_types2();
   }
 });
 
@@ -12230,7 +12508,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.28.1",
+      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: {
@@ -12278,6 +12556,7 @@ var require_package = __commonJS({
       license: "MIT",
       dependencies: {
         "@hono/node-server": "^1.13.7",
+        "@linear/sdk": "^29.0.0",
         chalk: "^4.1.2",
         esbuild: "^0.25.0",
         glob: "^10.3.10",
@@ -12390,12 +12669,14 @@ Use 'prjct --help' to see available commands.`);
       const param = parsedArgs.join(" ") || null;
       const standardCommands = {
         // Core workflow
+        work: /* @__PURE__ */ __name((p) => commands.work(p), "work"),
         done: /* @__PURE__ */ __name(() => commands.done(), "done"),
         next: /* @__PURE__ */ __name(() => commands.next(), "next"),
         pause: /* @__PURE__ */ __name((p) => commands.pause(p || ""), "pause"),
         resume: /* @__PURE__ */ __name((p) => commands.resume(p), "resume"),
         // Planning
         init: /* @__PURE__ */ __name((p) => commands.init(p), "init"),
+        feature: /* @__PURE__ */ __name((p) => commands.feature(p || ""), "feature"),
         bug: /* @__PURE__ */ __name((p) => commands.bug(p || ""), "bug"),
         idea: /* @__PURE__ */ __name((p) => commands.idea(p || ""), "idea"),
         spec: /* @__PURE__ */ __name((p) => commands.spec(p), "spec"),
@@ -12503,7 +12784,7 @@ init_version();
 init_editors_config();
 
 // core/server/server.ts
-import { Hono as Hono2 } from "hono";
+import { Hono as Hono3 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 
@@ -12632,6 +12913,410 @@ function createRoutes(projectId, _projectPath) {
 }
 __name(createRoutes, "createRoutes");
 
+// core/server/routes-extended.ts
+import { Hono as Hono2 } from "hono";
+import fs4 from "fs/promises";
+import path4 from "path";
+import os2 from "os";
+import * as jsonc2 from "jsonc-parser";
+var GLOBAL_BASE = path4.join(os2.homedir(), ".prjct-cli");
+var PROJECTS_DIR = path4.join(GLOBAL_BASE, "projects");
+async function readJsonFile2(filePath) {
+  try {
+    const content = await fs4.readFile(filePath, "utf-8");
+    const errors = [];
+    const result = jsonc2.parse(content, errors);
+    return errors.length > 0 ? null : result;
+  } catch {
+    return null;
+  }
+}
+__name(readJsonFile2, "readJsonFile");
+async function writeJsonFile2(filePath, data) {
+  try {
+    await fs4.mkdir(path4.dirname(filePath), { recursive: true });
+    await fs4.writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(writeJsonFile2, "writeJsonFile");
+function getProjectPath(projectId) {
+  return path4.join(PROJECTS_DIR, projectId);
+}
+__name(getProjectPath, "getProjectPath");
+async function getProjectConfig(projectId) {
+  const configPath = path4.join(getProjectPath(projectId), "project.json");
+  return await readJsonFile2(configPath);
+}
+__name(getProjectConfig, "getProjectConfig");
+async function calculateDuration(startedAt) {
+  if (!startedAt) return "";
+  const start = new Date(startedAt);
+  const now = /* @__PURE__ */ new Date();
+  const elapsed = now.getTime() - start.getTime();
+  const hours = Math.floor(elapsed / (1e3 * 60 * 60));
+  const minutes = Math.floor(elapsed % (1e3 * 60 * 60) / (1e3 * 60));
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+}
+__name(calculateDuration, "calculateDuration");
+function createExtendedRoutes() {
+  const api = new Hono2();
+  api.get("/projects", async (c) => {
+    try {
+      await fs4.mkdir(PROJECTS_DIR, { recursive: true });
+      const entries = await fs4.readdir(PROJECTS_DIR, { withFileTypes: true });
+      const projectIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+      const projects = await Promise.all(
+        projectIds.map(async (id) => {
+          const projectPath = getProjectPath(id);
+          const config = await getProjectConfig(id);
+          const state = await readJsonFile2(
+            path4.join(projectPath, "storage/state.json")
+          );
+          const queue = await readJsonFile2(
+            path4.join(projectPath, "storage/queue.json")
+          );
+          const ideas = await readJsonFile2(
+            path4.join(projectPath, "storage/ideas.json")
+          );
+          const shipped = await readJsonFile2(
+            path4.join(projectPath, "storage/shipped.json")
+          );
+          const currentTask = state?.currentTask;
+          const duration = await calculateDuration(currentTask?.startedAt);
+          return {
+            id,
+            name: config?.name || id.slice(0, 8),
+            path: config?.path || null,
+            currentTask: currentTask ? {
+              ...currentTask,
+              duration
+            } : null,
+            pausedTask: state?.previousTask || null,
+            stats: {
+              queueCount: queue?.tasks?.filter((t) => !t.completed)?.length || 0,
+              ideasCount: ideas?.ideas?.filter((i) => i.status === "pending")?.length || 0,
+              shippedCount: shipped?.shipped?.length || 0
+            }
+          };
+        })
+      );
+      projects.sort((a, b) => {
+        if (a.currentTask && !b.currentTask) return -1;
+        if (!a.currentTask && b.currentTask) return 1;
+        return (a.name || "").localeCompare(b.name || "");
+      });
+      return c.json({ projects });
+    } catch (error) {
+      return c.json({ projects: [], error: String(error) }, 500);
+    }
+  });
+  api.get("/projects/:id/full", async (c) => {
+    const projectId = c.req.param("id");
+    const projectPath = getProjectPath(projectId);
+    try {
+      const [config, state, queue, ideas, shipped, roadmap] = await Promise.all([
+        getProjectConfig(projectId),
+        readJsonFile2(path4.join(projectPath, "storage/state.json")),
+        readJsonFile2(path4.join(projectPath, "storage/queue.json")),
+        readJsonFile2(path4.join(projectPath, "storage/ideas.json")),
+        readJsonFile2(path4.join(projectPath, "storage/shipped.json")),
+        readJsonFile2(path4.join(projectPath, "planning/roadmap.json"))
+      ]);
+      if (state?.currentTask?.startedAt) {
+        state.currentTask.duration = await calculateDuration(state.currentTask.startedAt);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const weekStart = new Date(todayStart);
+      weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+      const completedToday = queue?.tasks?.filter((t) => {
+        if (!t.completed || !t.completedAt) return false;
+        return new Date(t.completedAt) >= todayStart;
+      })?.length || 0;
+      const completedThisWeek = queue?.tasks?.filter((t) => {
+        if (!t.completed || !t.completedAt) return false;
+        return new Date(t.completedAt) >= weekStart;
+      })?.length || 0;
+      return c.json({
+        id: projectId,
+        name: config?.name || projectId,
+        path: config?.path,
+        state: state || { currentTask: null, previousTask: null, lastUpdated: "" },
+        queue: queue || { tasks: [], lastUpdated: "" },
+        ideas: ideas || { ideas: [], lastUpdated: "" },
+        shipped: shipped || { shipped: [], lastUpdated: "" },
+        roadmap: roadmap || { features: [], backlog: [], lastUpdated: "" },
+        stats: {
+          tasksToday: completedToday,
+          tasksThisWeek: completedThisWeek,
+          queueCount: queue?.tasks?.filter((t) => !t.completed)?.length || 0,
+          ideasCount: ideas?.ideas?.filter((i) => i.status === "pending")?.length || 0,
+          shippedCount: shipped?.shipped?.length || 0
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (error) {
+      return c.json({ error: String(error) }, 500);
+    }
+  });
+  api.post("/projects/:id/task/complete", async (c) => {
+    const projectId = c.req.param("id");
+    const projectPath = getProjectPath(projectId);
+    const statePath = path4.join(projectPath, "storage/state.json");
+    try {
+      const state = await readJsonFile2(statePath);
+      if (!state?.currentTask) {
+        return c.json({ success: false, error: "No active task" }, 400);
+      }
+      const completedTask = state.currentTask;
+      const newState = {
+        currentTask: null,
+        previousTask: null,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeJsonFile2(statePath, newState);
+      return c.json({
+        success: true,
+        completedTask,
+        message: `Completed: ${completedTask.description}`
+      });
+    } catch (error) {
+      return c.json({ success: false, error: String(error) }, 500);
+    }
+  });
+  api.post("/projects/:id/task/pause", async (c) => {
+    const projectId = c.req.param("id");
+    const projectPath = getProjectPath(projectId);
+    const statePath = path4.join(projectPath, "storage/state.json");
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      const reason2 = body.reason;
+      const state = await readJsonFile2(statePath);
+      if (!state?.currentTask) {
+        return c.json({ success: false, error: "No active task" }, 400);
+      }
+      const pausedTask = {
+        id: state.currentTask.id,
+        description: state.currentTask.description,
+        status: "paused",
+        startedAt: state.currentTask.startedAt,
+        pausedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        pauseReason: reason2
+      };
+      const newState = {
+        currentTask: null,
+        previousTask: pausedTask,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeJsonFile2(statePath, newState);
+      return c.json({
+        success: true,
+        pausedTask,
+        message: `Paused: ${pausedTask.description}`
+      });
+    } catch (error) {
+      return c.json({ success: false, error: String(error) }, 500);
+    }
+  });
+  api.post("/projects/:id/task/resume", async (c) => {
+    const projectId = c.req.param("id");
+    const projectPath = getProjectPath(projectId);
+    const statePath = path4.join(projectPath, "storage/state.json");
+    try {
+      const state = await readJsonFile2(statePath);
+      if (!state?.previousTask) {
+        return c.json({ success: false, error: "No paused task" }, 400);
+      }
+      const resumedTask = {
+        id: state.previousTask.id,
+        description: state.previousTask.description,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: `sess_${Date.now().toString(36)}`
+      };
+      const newState = {
+        currentTask: resumedTask,
+        previousTask: null,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeJsonFile2(statePath, newState);
+      return c.json({
+        success: true,
+        resumedTask,
+        message: `Resumed: ${resumedTask.description}`
+      });
+    } catch (error) {
+      return c.json({ success: false, error: String(error) }, 500);
+    }
+  });
+  api.post("/projects/:id/queue/start", async (c) => {
+    const projectId = c.req.param("id");
+    const projectPath = getProjectPath(projectId);
+    const statePath = path4.join(projectPath, "storage/state.json");
+    const queuePath = path4.join(projectPath, "storage/queue.json");
+    try {
+      const body = await c.req.json();
+      const { taskId } = body;
+      if (!taskId) {
+        return c.json({ success: false, error: "taskId required" }, 400);
+      }
+      const state = await readJsonFile2(statePath);
+      const queue = await readJsonFile2(queuePath);
+      if (state?.currentTask) {
+        return c.json({ success: false, error: "Complete or pause current task first" }, 400);
+      }
+      const task = queue?.tasks?.find((t) => t.id === taskId);
+      if (!task) {
+        return c.json({ success: false, error: "Task not found in queue" }, 404);
+      }
+      const newTask = {
+        id: task.id,
+        description: task.description,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: `sess_${Date.now().toString(36)}`,
+        featureId: task.featureId
+      };
+      const newState = {
+        currentTask: newTask,
+        previousTask: null,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeJsonFile2(statePath, newState);
+      return c.json({
+        success: true,
+        task: newTask,
+        message: `Started: ${newTask.description}`
+      });
+    } catch (error) {
+      return c.json({ success: false, error: String(error) }, 500);
+    }
+  });
+  api.post("/projects/:id/ideas", async (c) => {
+    const projectId = c.req.param("id");
+    const projectPath = getProjectPath(projectId);
+    const ideasPath = path4.join(projectPath, "storage/ideas.json");
+    try {
+      const body = await c.req.json();
+      const { text, priority = "medium", tags = [] } = body;
+      if (!text) {
+        return c.json({ success: false, error: "text required" }, 400);
+      }
+      const ideas = await readJsonFile2(ideasPath) || { ideas: [], lastUpdated: "" };
+      const newIdea = {
+        id: `idea_${Date.now().toString(36)}`,
+        text,
+        status: "pending",
+        priority,
+        tags,
+        addedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      ideas.ideas.unshift(newIdea);
+      ideas.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      await writeJsonFile2(ideasPath, ideas);
+      return c.json({
+        success: true,
+        idea: newIdea,
+        message: `Captured: ${text.slice(0, 50)}...`
+      });
+    } catch (error) {
+      return c.json({ success: false, error: String(error) }, 500);
+    }
+  });
+  api.get("/stats/global", async (c) => {
+    try {
+      await fs4.mkdir(PROJECTS_DIR, { recursive: true });
+      const entries = await fs4.readdir(PROJECTS_DIR, { withFileTypes: true });
+      const projectIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+      let totalTasks = 0;
+      let totalIdeas = 0;
+      let totalShipped = 0;
+      let activeProjects = 0;
+      for (const id of projectIds) {
+        const projectPath = getProjectPath(id);
+        const state = await readJsonFile2(path4.join(projectPath, "storage/state.json"));
+        const queue = await readJsonFile2(path4.join(projectPath, "storage/queue.json"));
+        const ideas = await readJsonFile2(path4.join(projectPath, "storage/ideas.json"));
+        const shipped = await readJsonFile2(path4.join(projectPath, "storage/shipped.json"));
+        if (state?.currentTask) activeProjects++;
+        totalTasks += queue?.tasks?.filter((t) => !t.completed)?.length || 0;
+        totalIdeas += ideas?.ideas?.filter((i) => i.status === "pending")?.length || 0;
+        totalShipped += shipped?.shipped?.length || 0;
+      }
+      return c.json({
+        totalProjects: projectIds.length,
+        activeProjects,
+        totalTasks,
+        totalIdeas,
+        totalShipped,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (error) {
+      return c.json({ error: String(error) }, 500);
+    }
+  });
+  api.get("/status-bar/compact", async (c) => {
+    try {
+      const cwd = c.req.query("cwd");
+      await fs4.mkdir(PROJECTS_DIR, { recursive: true });
+      const entries = await fs4.readdir(PROJECTS_DIR, { withFileTypes: true });
+      const projectIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+      let targetProjectId = null;
+      if (cwd) {
+        for (const id of projectIds) {
+          const config = await getProjectConfig(id);
+          const projectPath = config?.repoPath || config?.path;
+          if (projectPath && cwd.startsWith(projectPath)) {
+            targetProjectId = id;
+            break;
+          }
+        }
+      }
+      let activeProject = null;
+      let activeTask = null;
+      let pausedTask = null;
+      const idsToCheck = targetProjectId ? [targetProjectId] : projectIds;
+      for (const id of idsToCheck) {
+        const projectPath = getProjectPath(id);
+        const state = await readJsonFile2(path4.join(projectPath, "storage/state.json"));
+        const config = await getProjectConfig(id);
+        if (state?.currentTask) {
+          activeProject = { id, name: config?.name || id, path: config?.repoPath || config?.path };
+          activeTask = {
+            ...state.currentTask,
+            duration: await calculateDuration(state.currentTask.startedAt)
+          };
+          break;
+        }
+        if (state?.previousTask && !pausedTask) {
+          activeProject = { id, name: config?.name || id, path: config?.repoPath || config?.path };
+          pausedTask = state.previousTask;
+        }
+      }
+      return c.json({
+        hasActiveTask: !!activeTask,
+        hasPausedTask: !!pausedTask,
+        activeProject,
+        activeTask,
+        pausedTask,
+        totalProjects: projectIds.length,
+        // Include whether we filtered by cwd
+        filtered: !!targetProjectId,
+        cwd: cwd || null,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (error) {
+      return c.json({ error: String(error) }, 500);
+    }
+  });
+  return api;
+}
+__name(createExtendedRoutes, "createExtendedRoutes");
+
 // core/server/sse.ts
 import { streamSSE } from "hono/streaming";
 function createSSEManager() {
@@ -12725,7 +13410,7 @@ __name(isBun, "isBun");
 
 // core/server/server.ts
 function createServer(config) {
-  const app = new Hono2();
+  const app = new Hono3();
   const sseManager = createSSEManager();
   if (config.enableCors !== false) {
     app.use("*", cors({
@@ -12749,11 +13434,18 @@ function createServer(config) {
       ideas: "/api/ideas",
       roadmap: "/api/roadmap",
       shipped: "/api/shipped",
-      events: "/api/events"
+      events: "/api/events",
+      // Extended endpoints for status-bar
+      projects: "/api/projects",
+      projectFull: "/api/projects/:id/full",
+      statusBarCompact: "/api/status-bar/compact",
+      globalStats: "/api/stats/global"
     }
   }));
   const routes = createRoutes(config.projectId, config.projectPath);
   app.route("/api", routes);
+  const extendedRoutes = createExtendedRoutes();
+  app.route("/api", extendedRoutes);
   app.get("/api/events", (c) => {
     return sseManager.handleConnection(c);
   });