prjct-cli 1.2.2 → 1.3.0

package/dist/bin/prjct.mjs

@@ -16,10 +16,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __glob = (map) => (path60) => {
-  var fn = map[path60];
+var __glob = (map) => (path61) => {
+  var fn = map[path61];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path60);
+  throw new Error("Module not found in bundle: " + path61);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -2541,15 +2541,219 @@ ${chalk2.bold(title)}`);
   }
 });
 
+// core/services/session-tracker.ts
+var session_tracker_exports = {};
+__export(session_tracker_exports, {
+  default: () => session_tracker_default,
+  sessionTracker: () => sessionTracker
+});
+import fs9 from "node:fs/promises";
+import path9 from "node:path";
+var SESSION_FILENAME, DEFAULT_IDLE_TIMEOUT_MS, MAX_COMMAND_HISTORY, MAX_FILE_HISTORY, SessionTracker, sessionTracker, session_tracker_default;
+var init_session_tracker = __esm({
+  "core/services/session-tracker.ts"() {
+    "use strict";
+    init_path_manager();
+    init_fs();
+    init_date_helper();
+    SESSION_FILENAME = "session.json";
+    DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+    MAX_COMMAND_HISTORY = 50;
+    MAX_FILE_HISTORY = 200;
+    SessionTracker = class {
+      static {
+        __name(this, "SessionTracker");
+      }
+      getPath(projectId) {
+        return path_manager_default.getStoragePath(projectId, SESSION_FILENAME);
+      }
+      /**
+       * Read session file from disk
+       */
+      async read(projectId) {
+        const filePath = this.getPath(projectId);
+        try {
+          const content = await fs9.readFile(filePath, "utf-8");
+          return JSON.parse(content);
+        } catch (error) {
+          if (isNotFoundError(error) || error instanceof SyntaxError) {
+            return this.getDefault();
+          }
+          throw error;
+        }
+      }
+      /**
+       * Write session file to disk
+       */
+      async write(projectId, data) {
+        const filePath = this.getPath(projectId);
+        await fs9.mkdir(path9.dirname(filePath), { recursive: true });
+        await fs9.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+      }
+      getDefault() {
+        return {
+          current: null,
+          config: {
+            idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS
+          }
+        };
+      }
+      /**
+       * Check if a session has expired based on idle timeout
+       */
+      isExpired(session, timeoutMs) {
+        const lastActivity = new Date(session.lastActivity).getTime();
+        const now = Date.now();
+        return now - lastActivity > timeoutMs;
+      }
+      /**
+       * Touch session — create new or resume existing.
+       * Called at the start of every CLI command.
+       * Returns the active session.
+       */
+      async touch(projectId) {
+        const file = await this.read(projectId);
+        const now = getTimestamp();
+        if (file.current && !this.isExpired(file.current, file.config.idleTimeoutMs)) {
+          file.current.lastActivity = now;
+          await this.write(projectId, file);
+          return file.current;
+        }
+        const session = {
+          id: crypto.randomUUID(),
+          projectId,
+          status: "active",
+          createdAt: now,
+          lastActivity: now,
+          commands: [],
+          files: []
+        };
+        file.current = session;
+        await this.write(projectId, file);
+        return session;
+      }
+      /**
+       * Record a command execution in the current session
+       */
+      async trackCommand(projectId, command, durationMs) {
+        const file = await this.read(projectId);
+        if (!file.current) return;
+        const now = getTimestamp();
+        file.current.lastActivity = now;
+        file.current.commands.push({
+          command,
+          timestamp: now,
+          durationMs
+        });
+        if (file.current.commands.length > MAX_COMMAND_HISTORY) {
+          file.current.commands = file.current.commands.slice(-MAX_COMMAND_HISTORY);
+        }
+        await this.write(projectId, file);
+      }
+      /**
+       * Record a file access in the current session
+       */
+      async trackFile(projectId, filePath, operation) {
+        const file = await this.read(projectId);
+        if (!file.current) return;
+        const now = getTimestamp();
+        file.current.lastActivity = now;
+        file.current.files.push({
+          path: filePath,
+          operation,
+          timestamp: now
+        });
+        if (file.current.files.length > MAX_FILE_HISTORY) {
+          file.current.files = file.current.files.slice(-MAX_FILE_HISTORY);
+        }
+        await this.write(projectId, file);
+      }
+      /**
+       * Get session info for display (used by `prjct status`)
+       */
+      async getInfo(projectId) {
+        const file = await this.read(projectId);
+        if (!file.current || this.isExpired(file.current, file.config.idleTimeoutMs)) {
+          return {
+            active: false,
+            id: null,
+            duration: null,
+            idleSince: null,
+            idleMs: 0,
+            expiresIn: null,
+            commandCount: 0,
+            commands: [],
+            filesRead: 0,
+            filesWritten: 0
+          };
+        }
+        const session = file.current;
+        const now = Date.now();
+        const createdAt = new Date(session.createdAt).getTime();
+        const lastActivity = new Date(session.lastActivity).getTime();
+        const idleMs = now - lastActivity;
+        const timeoutMs = file.config.idleTimeoutMs;
+        const expiresInMs = Math.max(0, timeoutMs - idleMs);
+        const uniqueCommands = session.commands.map((c) => c.command);
+        const filesRead = new Set(
+          session.files.filter((f) => f.operation === "read").map((f) => f.path)
+        ).size;
+        const filesWritten = new Set(
+          session.files.filter((f) => f.operation === "write").map((f) => f.path)
+        ).size;
+        return {
+          active: true,
+          id: session.id,
+          duration: formatDuration(now - createdAt),
+          idleSince: session.lastActivity,
+          idleMs,
+          expiresIn: formatDuration(expiresInMs),
+          commandCount: session.commands.length,
+          commands: uniqueCommands,
+          filesRead,
+          filesWritten
+        };
+      }
+      /**
+       * Expire the current session (cleanup)
+       */
+      async expire(projectId) {
+        const file = await this.read(projectId);
+        if (file.current) {
+          file.current.status = "expired";
+          file.current = null;
+          await this.write(projectId, file);
+        }
+      }
+      /**
+       * Check and expire stale session if needed.
+       * Called on startup to clean up leftover sessions.
+       * Returns true if a session was expired.
+       */
+      async expireIfStale(projectId) {
+        const file = await this.read(projectId);
+        if (file.current && this.isExpired(file.current, file.config.idleTimeoutMs)) {
+          file.current = null;
+          await this.write(projectId, file);
+          return true;
+        }
+        return false;
+      }
+    };
+    sessionTracker = new SessionTracker();
+    session_tracker_default = sessionTracker;
+  }
+});
+
 // core/cli/start.ts
 var start_exports = {};
 __export(start_exports, {
   default: () => start_default,
   runStart: () => runStart
 });
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import os4 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 import chalk3 from "chalk";
 function showBanner() {
   console.clear();
@@ -2652,15 +2856,15 @@ async function installRouter(provider) {
     return false;
   }
   try {
-    const commandsDir = path9.join(config.configDir, "commands");
-    fs9.mkdirSync(commandsDir, { recursive: true });
+    const commandsDir = path10.join(config.configDir, "commands");
+    fs10.mkdirSync(commandsDir, { recursive: true });
     const { getPackageRoot: getPackageRoot2 } = await Promise.resolve().then(() => (init_version(), version_exports));
     const packageRoot = getPackageRoot2();
     const routerFile = provider === "claude" ? "p.md" : "p.toml";
-    const src = path9.join(packageRoot, "templates", "commands", routerFile);
-    const dest = path9.join(commandsDir, routerFile);
-    if (fs9.existsSync(src)) {
-      fs9.copyFileSync(src, dest);
+    const src = path10.join(packageRoot, "templates", "commands", routerFile);
+    const dest = path10.join(commandsDir, routerFile);
+    if (fs10.existsSync(src)) {
+      fs10.copyFileSync(src, dest);
       return true;
     }
     return false;
@@ -2677,16 +2881,16 @@ async function installGlobalConfig(provider) {
     return false;
   }
   try {
-    fs9.mkdirSync(config.configDir, { recursive: true });
+    fs10.mkdirSync(config.configDir, { recursive: true });
     const { getPackageRoot: getPackageRoot2 } = await Promise.resolve().then(() => (init_version(), version_exports));
     const packageRoot = getPackageRoot2();
     const configFile = provider === "claude" ? "CLAUDE.md" : "GEMINI.md";
-    const src = path9.join(packageRoot, "templates", "global", configFile);
-    const dest = path9.join(config.configDir, configFile);
-    if (fs9.existsSync(src)) {
-      const content = fs9.readFileSync(src, "utf-8");
-      if (fs9.existsSync(dest)) {
-        const existing = fs9.readFileSync(dest, "utf-8");
+    const src = path10.join(packageRoot, "templates", "global", configFile);
+    const dest = path10.join(config.configDir, configFile);
+    if (fs10.existsSync(src)) {
+      const content = fs10.readFileSync(src, "utf-8");
+      if (fs10.existsSync(dest)) {
+        const existing = fs10.readFileSync(dest, "utf-8");
         const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
         const endMarker = "<!-- prjct:end - DO NOT REMOVE THIS MARKER -->";
         if (existing.includes(startMarker) && existing.includes(endMarker)) {
@@ -2696,14 +2900,14 @@ async function installGlobalConfig(provider) {
             content.indexOf(startMarker),
             content.indexOf(endMarker) + endMarker.length
           );
-          fs9.writeFileSync(dest, before + prjctSection + after);
+          fs10.writeFileSync(dest, before + prjctSection + after);
         } else {
-          fs9.writeFileSync(dest, `${existing}
+          fs10.writeFileSync(dest, `${existing}
 
 ${content}`);
         }
       } else {
-        fs9.writeFileSync(dest, content);
+        fs10.writeFileSync(dest, content);
       }
       return true;
     }
@@ -2716,9 +2920,9 @@ ${content}`);
   }
 }
 async function saveSetupConfig(providers) {
-  const configDir = path9.join(os4.homedir(), ".prjct-cli", "config");
-  fs9.mkdirSync(configDir, { recursive: true });
-  const configPath = path9.join(configDir, "installed-editors.json");
+  const configDir = path10.join(os4.homedir(), ".prjct-cli", "config");
+  fs10.mkdirSync(configDir, { recursive: true });
+  const configPath = path10.join(configDir, "installed-editors.json");
   const config = {
     version: VERSION,
     providers,
@@ -2726,9 +2930,9 @@ async function saveSetupConfig(providers) {
     // deprecated, for backward compat
     provider: providers[0],
     lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
-    path: path9.join(os4.homedir(), `.${providers[0]}`, "commands")
+    path: path10.join(os4.homedir(), `.${providers[0]}`, "commands")
   };
-  fs9.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  fs10.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
 function showCompletion(providers) {
   console.log(`
@@ -2756,9 +2960,9 @@ ${chalk3.green.bold("  \u2713 Setup complete!")}
 }
 async function runStart() {
   showBanner();
-  const configPath = path9.join(os4.homedir(), ".prjct-cli", "config", "installed-editors.json");
-  if (fs9.existsSync(configPath)) {
-    const existing = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+  const configPath = path10.join(os4.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  if (fs10.existsSync(configPath)) {
+    const existing = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
     if (existing.version === VERSION) {
       console.log(`  ${chalk3.yellow("\u2139")} Already configured for v${VERSION}`);
       console.log(`  ${chalk3.dim("Run with --force to reconfigure")}
@@ -3111,8 +3315,8 @@ var init_cache = __esm({
 });
 
 // core/storage/storage-manager.ts
-import fs10 from "node:fs/promises";
-import path10 from "node:path";
+import fs11 from "node:fs/promises";
+import path11 from "node:path";
 var StorageManager;
 var init_storage_manager = __esm({
   "core/storage/storage-manager.ts"() {
@@ -3156,7 +3360,7 @@ var init_storage_manager = __esm({
         }
         const filePath = this.getStoragePath(projectId);
         try {
-          const content = await fs10.readFile(filePath, "utf-8");
+          const content = await fs11.readFile(filePath, "utf-8");
           const data = JSON.parse(content);
           this.cache.set(projectId, data);
           return data;
@@ -3173,13 +3377,13 @@ var init_storage_manager = __esm({
       async write(projectId, data) {
         const storagePath = this.getStoragePath(projectId);
         const contextPath = this.getContextPath(projectId, this.getMdFilename());
-        await fs10.mkdir(path10.dirname(storagePath), { recursive: true });
-        await fs10.mkdir(path10.dirname(contextPath), { recursive: true });
+        await fs11.mkdir(path11.dirname(storagePath), { recursive: true });
+        await fs11.mkdir(path11.dirname(contextPath), { recursive: true });
         const tempPath = `${storagePath}.${Date.now()}.tmp`;
-        await fs10.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-        await fs10.rename(tempPath, storagePath);
+        await fs11.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+        await fs11.rename(tempPath, storagePath);
         const md2 = this.toMarkdown(data);
-        await fs10.writeFile(contextPath, md2, "utf-8");
+        await fs11.writeFile(contextPath, md2, "utf-8");
         this.cache.set(projectId, data);
       }
       /**
@@ -3227,7 +3431,7 @@ var init_storage_manager = __esm({
       async exists(projectId) {
         const filePath = this.getStoragePath(projectId);
         try {
-          await fs10.access(filePath);
+          await fs11.access(filePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -3489,8 +3693,8 @@ var init_metrics_storage = __esm({
 
 // core/context-tools/files-tool.ts
 import { exec as execCallback2 } from "node:child_process";
-import fs11 from "node:fs/promises";
-import path11 from "node:path";
+import fs12 from "node:fs/promises";
+import path12 from "node:path";
 import { promisify as promisify2 } from "node:util";
 async function findRelevantFiles(taskDescription, projectPath, options = {}) {
   const startTime = Date.now();
@@ -3619,17 +3823,17 @@ async function getAllCodeFiles(projectPath) {
   const files = [];
   async function walk(dir, relativePath = "") {
     try {
-      const entries = await fs11.readdir(dir, { withFileTypes: true });
+      const entries = await fs12.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path11.join(dir, entry.name);
-        const relPath = path11.join(relativePath, entry.name);
+        const fullPath = path12.join(dir, entry.name);
+        const relPath = path12.join(relativePath, entry.name);
         if (entry.isDirectory()) {
           if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith(".")) {
             continue;
           }
           await walk(fullPath, relPath);
         } else if (entry.isFile()) {
-          const ext = path11.extname(entry.name).toLowerCase();
+          const ext = path12.extname(entry.name).toLowerCase();
           if (CODE_EXTENSIONS.has(ext)) {
             files.push(relPath);
           }
@@ -3726,7 +3930,7 @@ function scoreFile(filePath, keywords, gitRecency) {
       recencyScore = Math.min(1, recencyScore + 0.2);
     }
   }
-  const filename = path11.basename(filePath).toLowerCase();
+  const filename = path12.basename(filePath).toLowerCase();
   if (filename.includes("index") || filename.includes("main") || filename.includes("app") || filename.includes("entry")) {
     importScore = 0.5;
     reasons.push("import:0");
@@ -3923,14 +4127,14 @@ var init_files_tool = __esm({
 
 // core/context-tools/imports-tool.ts
 import { exec as execCallback3 } from "node:child_process";
-import fs12 from "node:fs/promises";
-import path12 from "node:path";
+import fs13 from "node:fs/promises";
+import path13 from "node:path";
 import { promisify as promisify3 } from "node:util";
 async function analyzeImports(filePath, projectPath = process.cwd(), options = {}) {
-  const absolutePath = path12.isAbsolute(filePath) ? filePath : path12.join(projectPath, filePath);
+  const absolutePath = path13.isAbsolute(filePath) ? filePath : path13.join(projectPath, filePath);
   let content;
   try {
-    content = await fs12.readFile(absolutePath, "utf-8");
+    content = await fs13.readFile(absolutePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return {
@@ -3947,7 +4151,7 @@ async function analyzeImports(filePath, projectPath = process.cwd(), options = {
     }
     throw error;
   }
-  const ext = path12.extname(filePath).toLowerCase();
+  const ext = path13.extname(filePath).toLowerCase();
   const language = EXT_TO_LANG[ext] || "unknown";
   const patterns = IMPORT_PATTERNS[language] || [];
   const imports = extractImports(content, patterns, absolutePath, projectPath);
@@ -4009,12 +4213,12 @@ function extractImports(content, patterns, absolutePath, projectPath) {
   return imports;
 }
 function resolveImport(source, fromFile, projectPath) {
-  const fileDir = path12.dirname(fromFile);
+  const fileDir = path13.dirname(fromFile);
   if (source.startsWith("@/")) {
-    const aliasPath = path12.join(projectPath, "src", source.slice(2));
+    const aliasPath = path13.join(projectPath, "src", source.slice(2));
     return tryResolve(aliasPath, projectPath);
   }
-  const resolved = path12.resolve(fileDir, source);
+  const resolved = path13.resolve(fileDir, source);
   return tryResolve(resolved, projectPath);
 }
 function tryResolve(basePath, projectPath) {
@@ -4022,9 +4226,9 @@ function tryResolve(basePath, projectPath) {
   for (const ext of extensions) {
     const fullPath = basePath + ext;
     try {
-      const fs51 = __require("node:fs");
-      if (fs51.existsSync(fullPath) && fs51.statSync(fullPath).isFile()) {
-        return path12.relative(projectPath, fullPath);
+      const fs52 = __require("node:fs");
+      if (fs52.existsSync(fullPath) && fs52.statSync(fullPath).isFile()) {
+        return path13.relative(projectPath, fullPath);
       }
     } catch {
     }
@@ -4033,8 +4237,8 @@ function tryResolve(basePath, projectPath) {
 }
 async function findImportedBy(filePath, projectPath) {
   const importedBy = [];
-  const baseName = path12.basename(filePath, path12.extname(filePath));
-  const _dirName = path12.dirname(filePath);
+  const baseName = path13.basename(filePath, path13.extname(filePath));
+  const _dirName = path13.dirname(filePath);
   try {
     const searchPatterns = [
       `from ['"].*${baseName}['"]`,
@@ -4548,13 +4752,13 @@ var init_token_counter = __esm({
 });
 
 // core/context-tools/signatures-tool.ts
-import fs13 from "node:fs/promises";
-import path13 from "node:path";
+import fs14 from "node:fs/promises";
+import path14 from "node:path";
 async function extractSignatures(filePath, projectPath = process.cwd()) {
-  const absolutePath = path13.isAbsolute(filePath) ? filePath : path13.join(projectPath, filePath);
+  const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.join(projectPath, filePath);
   let content;
   try {
-    content = await fs13.readFile(absolutePath, "utf-8");
+    content = await fs14.readFile(absolutePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return {
@@ -4568,7 +4772,7 @@ async function extractSignatures(filePath, projectPath = process.cwd()) {
     }
     throw error;
   }
-  const ext = path13.extname(filePath).toLowerCase();
+  const ext = path14.extname(filePath).toLowerCase();
   const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
   const patterns = LANGUAGE_PATTERNS[language];
   if (!patterns || patterns.length === 0) {
@@ -4595,13 +4799,13 @@ async function extractSignatures(filePath, projectPath = process.cwd()) {
   };
 }
 async function extractDirectorySignatures(dirPath, projectPath = process.cwd(), options = {}) {
-  const absolutePath = path13.isAbsolute(dirPath) ? dirPath : path13.join(projectPath, dirPath);
+  const absolutePath = path14.isAbsolute(dirPath) ? dirPath : path14.join(projectPath, dirPath);
   const results = [];
   async function processDir(dir) {
-    const entries = await fs13.readdir(dir, { withFileTypes: true });
+    const entries = await fs14.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path13.join(dir, entry.name);
-      const relativePath = path13.relative(projectPath, fullPath);
+      const fullPath = path14.join(dir, entry.name);
+      const relativePath = path14.relative(projectPath, fullPath);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git" || entry.name.startsWith(".")) {
           continue;
@@ -4610,7 +4814,7 @@ async function extractDirectorySignatures(dirPath, projectPath = process.cwd(),
           await processDir(fullPath);
         }
       } else if (entry.isFile()) {
-        const ext = path13.extname(entry.name).toLowerCase();
+        const ext = path14.extname(entry.name).toLowerCase();
         if (EXTENSION_TO_LANGUAGE[ext]) {
           const result = await extractSignatures(relativePath, projectPath);
           results.push(result);
@@ -4900,13 +5104,13 @@ var init_signatures_tool = __esm({
 });
 
 // core/context-tools/summary-tool.ts
-import fs14 from "node:fs/promises";
-import path14 from "node:path";
+import fs15 from "node:fs/promises";
+import path15 from "node:path";
 async function summarizeFile(filePath, projectPath = process.cwd()) {
-  const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.join(projectPath, filePath);
+  const absolutePath = path15.isAbsolute(filePath) ? filePath : path15.join(projectPath, filePath);
   let content;
   try {
-    content = await fs14.readFile(absolutePath, "utf-8");
+    content = await fs15.readFile(absolutePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return {
@@ -4919,7 +5123,7 @@ async function summarizeFile(filePath, projectPath = process.cwd()) {
     }
     throw error;
   }
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path15.extname(filePath).toLowerCase();
   const language = EXT_TO_LANG2[ext] || "unknown";
   const signaturesResult = await extractSignatures(filePath, projectPath);
   const importsResult = await analyzeImports(filePath, projectPath);
@@ -4941,13 +5145,13 @@ async function summarizeFile(filePath, projectPath = process.cwd()) {
   };
 }
 async function summarizeDirectory(dirPath, projectPath = process.cwd(), options = {}) {
-  const absolutePath = path14.isAbsolute(dirPath) ? dirPath : path14.join(projectPath, dirPath);
+  const absolutePath = path15.isAbsolute(dirPath) ? dirPath : path15.join(projectPath, dirPath);
   const results = [];
   async function processDir(dir) {
-    const entries = await fs14.readdir(dir, { withFileTypes: true });
+    const entries = await fs15.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path14.join(dir, entry.name);
-      const relativePath = path14.relative(projectPath, fullPath);
+      const fullPath = path15.join(dir, entry.name);
+      const relativePath = path15.relative(projectPath, fullPath);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git" || entry.name.startsWith(".")) {
           continue;
@@ -4956,7 +5160,7 @@ async function summarizeDirectory(dirPath, projectPath = process.cwd(), options
           await processDir(fullPath);
         }
       } else if (entry.isFile()) {
-        const ext = path14.extname(entry.name).toLowerCase();
+        const ext = path15.extname(entry.name).toLowerCase();
         if (EXT_TO_LANG2[ext]) {
           const result = await summarizeFile(relativePath, projectPath);
           results.push(result);
@@ -5006,7 +5210,7 @@ function extractFilePurpose(content, language) {
     }
   }
   const fileName = content.split("\n")[0] || "";
-  return `Module: ${path14.basename(fileName, path14.extname(fileName))}`;
+  return `Module: ${path15.basename(fileName, path15.extname(fileName))}`;
 }
 function extractDescriptionFromDocstring(docstring) {
   return docstring.replace(/^\/\*\*\s*/, "").replace(/\*\/$/, "").replace(/^\/\/\/?\s*/, "").replace(/^#\s*/, "").replace(/^"""\s*/, "").replace(/"""\s*$/, "").trim().split("\n")[0].trim();
@@ -5206,11 +5410,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs51 = await import("node:fs/promises");
-  const path60 = await import("node:path");
-  const fullPath = path60.isAbsolute(filePath) ? filePath : path60.join(projectPath, filePath);
+  const fs52 = await import("node:fs/promises");
+  const path61 = await import("node:path");
+  const fullPath = path61.isAbsolute(filePath) ? filePath : path61.join(projectPath, filePath);
   try {
-    const stat = await fs51.stat(fullPath);
+    const stat = await fs52.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5277,11 +5481,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs51 = await import("node:fs/promises");
-  const path60 = await import("node:path");
-  const fullPath = path60.isAbsolute(targetPath) ? targetPath : path60.join(projectPath, targetPath);
+  const fs52 = await import("node:fs/promises");
+  const path61 = await import("node:path");
+  const fullPath = path61.isAbsolute(targetPath) ? targetPath : path61.join(projectPath, targetPath);
   try {
-    const stat = await fs51.stat(fullPath);
+    const stat = await fs52.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5441,8 +5645,8 @@ __export(hooks_service_exports, {
   default: () => hooks_service_default,
   hooksService: () => hooksService
 });
-import fs15 from "node:fs";
-import path15 from "node:path";
+import fs16 from "node:fs";
+import path16 from "node:path";
 import chalk4 from "chalk";
 function getPostCommitScript() {
   return `#!/bin/sh
@@ -5505,13 +5709,13 @@ exit 0
 }
 function detectHookManagers(projectPath) {
   const detected = [];
-  if (fs15.existsSync(path15.join(projectPath, "lefthook.yml")) || fs15.existsSync(path15.join(projectPath, "lefthook.yaml"))) {
+  if (fs16.existsSync(path16.join(projectPath, "lefthook.yml")) || fs16.existsSync(path16.join(projectPath, "lefthook.yaml"))) {
     detected.push("lefthook");
   }
-  if (fs15.existsSync(path15.join(projectPath, ".husky")) || fs15.existsSync(path15.join(projectPath, ".husky", "_"))) {
+  if (fs16.existsSync(path16.join(projectPath, ".husky")) || fs16.existsSync(path16.join(projectPath, ".husky", "_"))) {
     detected.push("husky");
   }
-  if (fs15.existsSync(path15.join(projectPath, ".git"))) {
+  if (fs16.existsSync(path16.join(projectPath, ".git"))) {
     detected.push("direct");
   }
   return detected;
@@ -5522,9 +5726,9 @@ function selectStrategy(detected) {
   return "direct";
 }
 function installLefthook(projectPath, hooks) {
-  const configFile = fs15.existsSync(path15.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
-  const configPath = path15.join(projectPath, configFile);
-  let content = fs15.readFileSync(configPath, "utf-8");
+  const configFile = fs16.existsSync(path16.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
+  const configPath = path16.join(projectPath, configFile);
+  let content = fs16.readFileSync(configPath, "utf-8");
   for (const hook of hooks) {
     const sectionName = hook;
     const commandName = `prjct-sync-${hook}`;
@@ -5553,87 +5757,87 @@ ${sectionName}:
 ${hookBlock}`;
     }
   }
-  fs15.writeFileSync(configPath, content, "utf-8");
+  fs16.writeFileSync(configPath, content, "utf-8");
   return true;
 }
 function installHusky(projectPath, hooks) {
-  const huskyDir = path15.join(projectPath, ".husky");
+  const huskyDir = path16.join(projectPath, ".husky");
   for (const hook of hooks) {
-    const hookPath = path15.join(huskyDir, hook);
+    const hookPath = path16.join(huskyDir, hook);
     const script = hook === "post-commit" ? getPostCommitScript() : getPostCheckoutScript();
-    if (fs15.existsSync(hookPath)) {
-      const existing = fs15.readFileSync(hookPath, "utf-8");
+    if (fs16.existsSync(hookPath)) {
+      const existing = fs16.readFileSync(hookPath, "utf-8");
       if (existing.includes("prjct sync")) {
         continue;
       }
-      fs15.appendFileSync(hookPath, "\n# prjct auto-sync\nprjct sync --quiet --yes &\n");
+      fs16.appendFileSync(hookPath, "\n# prjct auto-sync\nprjct sync --quiet --yes &\n");
     } else {
-      fs15.writeFileSync(hookPath, script, { mode: 493 });
+      fs16.writeFileSync(hookPath, script, { mode: 493 });
     }
   }
   return true;
 }
 function installDirect(projectPath, hooks) {
-  const hooksDir = path15.join(projectPath, ".git", "hooks");
-  if (!fs15.existsSync(hooksDir)) {
-    fs15.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path16.join(projectPath, ".git", "hooks");
+  if (!fs16.existsSync(hooksDir)) {
+    fs16.mkdirSync(hooksDir, { recursive: true });
   }
   for (const hook of hooks) {
-    const hookPath = path15.join(hooksDir, hook);
+    const hookPath = path16.join(hooksDir, hook);
     const script = hook === "post-commit" ? getPostCommitScript() : getPostCheckoutScript();
-    if (fs15.existsSync(hookPath)) {
-      const existing = fs15.readFileSync(hookPath, "utf-8");
+    if (fs16.existsSync(hookPath)) {
+      const existing = fs16.readFileSync(hookPath, "utf-8");
       if (existing.includes("prjct sync")) {
         continue;
       }
-      fs15.appendFileSync(hookPath, `
+      fs16.appendFileSync(hookPath, `
 # prjct auto-sync
 ${script.split("\n").slice(1).join("\n")}`);
     } else {
-      fs15.writeFileSync(hookPath, script, { mode: 493 });
+      fs16.writeFileSync(hookPath, script, { mode: 493 });
     }
   }
   return true;
 }
 function uninstallLefthook(projectPath) {
-  const configFile = fs15.existsSync(path15.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
-  const configPath = path15.join(projectPath, configFile);
-  if (!fs15.existsSync(configPath)) return false;
-  let content = fs15.readFileSync(configPath, "utf-8");
+  const configFile = fs16.existsSync(path16.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
+  const configPath = path16.join(projectPath, configFile);
+  if (!fs16.existsSync(configPath)) return false;
+  let content = fs16.readFileSync(configPath, "utf-8");
   content = content.replace(/\s*prjct-sync-[\w-]+:[\s\S]*?(?=\n\S|\n*$)/g, "");
   content = content.replace(/^(post-commit|post-checkout):\s*commands:\s*$/gm, "");
-  fs15.writeFileSync(configPath, `${content.trimEnd()}
+  fs16.writeFileSync(configPath, `${content.trimEnd()}
 `, "utf-8");
   return true;
 }
 function uninstallHusky(projectPath) {
-  const huskyDir = path15.join(projectPath, ".husky");
+  const huskyDir = path16.join(projectPath, ".husky");
   for (const hook of ["post-commit", "post-checkout"]) {
-    const hookPath = path15.join(huskyDir, hook);
-    if (!fs15.existsSync(hookPath)) continue;
-    const content = fs15.readFileSync(hookPath, "utf-8");
+    const hookPath = path16.join(huskyDir, hook);
+    if (!fs16.existsSync(hookPath)) continue;
+    const content = fs16.readFileSync(hookPath, "utf-8");
     if (!content.includes("prjct sync")) continue;
     const cleaned = content.split("\n").filter((line) => !line.includes("prjct sync") && !line.includes("prjct auto-sync")).join("\n");
     if (cleaned.trim() === "#!/bin/sh" || cleaned.trim() === "#!/usr/bin/env sh") {
-      fs15.unlinkSync(hookPath);
+      fs16.unlinkSync(hookPath);
     } else {
-      fs15.writeFileSync(hookPath, cleaned, { mode: 493 });
+      fs16.writeFileSync(hookPath, cleaned, { mode: 493 });
     }
   }
   return true;
 }
 function uninstallDirect(projectPath) {
-  const hooksDir = path15.join(projectPath, ".git", "hooks");
+  const hooksDir = path16.join(projectPath, ".git", "hooks");
   for (const hook of ["post-commit", "post-checkout"]) {
-    const hookPath = path15.join(hooksDir, hook);
-    if (!fs15.existsSync(hookPath)) continue;
-    const content = fs15.readFileSync(hookPath, "utf-8");
+    const hookPath = path16.join(hooksDir, hook);
+    if (!fs16.existsSync(hookPath)) continue;
+    const content = fs16.readFileSync(hookPath, "utf-8");
     if (!content.includes("prjct sync")) continue;
     if (content.includes("Installed by: prjct hooks install")) {
-      fs15.unlinkSync(hookPath);
+      fs16.unlinkSync(hookPath);
     } else {
       const cleaned = content.split("\n").filter((line) => !line.includes("prjct sync") && !line.includes("prjct auto-sync")).join("\n");
-      fs15.writeFileSync(hookPath, cleaned, { mode: 493 });
+      fs16.writeFileSync(hookPath, cleaned, { mode: 493 });
     }
   }
   return true;
@@ -5852,24 +6056,24 @@ var init_hooks_service = __esm({
       // ==========================================================================
       isHookInstalled(projectPath, hook, strategy) {
         if (strategy === "lefthook") {
-          const configFile = fs15.existsSync(path15.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
-          const configPath = path15.join(projectPath, configFile);
-          if (!fs15.existsSync(configPath)) return false;
-          const content = fs15.readFileSync(configPath, "utf-8");
+          const configFile = fs16.existsSync(path16.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
+          const configPath = path16.join(projectPath, configFile);
+          if (!fs16.existsSync(configPath)) return false;
+          const content = fs16.readFileSync(configPath, "utf-8");
           return content.includes(`prjct-sync-${hook}`);
         }
         if (strategy === "husky") {
-          const hookPath2 = path15.join(projectPath, ".husky", hook);
-          if (!fs15.existsSync(hookPath2)) return false;
-          return fs15.readFileSync(hookPath2, "utf-8").includes("prjct sync");
+          const hookPath2 = path16.join(projectPath, ".husky", hook);
+          if (!fs16.existsSync(hookPath2)) return false;
+          return fs16.readFileSync(hookPath2, "utf-8").includes("prjct sync");
         }
-        const hookPath = path15.join(projectPath, ".git", "hooks", hook);
-        if (!fs15.existsSync(hookPath)) return false;
-        return fs15.readFileSync(hookPath, "utf-8").includes("prjct sync");
+        const hookPath = path16.join(projectPath, ".git", "hooks", hook);
+        if (!fs16.existsSync(hookPath)) return false;
+        return fs16.readFileSync(hookPath, "utf-8").includes("prjct sync");
       }
       getHookPath(projectPath, hook, strategy) {
         if (strategy === "lefthook") {
-          return fs15.existsSync(path15.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
+          return fs16.existsSync(path16.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
         }
         if (strategy === "husky") {
           return `.husky/${hook}`;
@@ -5880,15 +6084,15 @@ var init_hooks_service = __esm({
         const projectId = await config_manager_default.getProjectId(projectPath);
         if (!projectId) return null;
         try {
-          const projectJsonPath = path15.join(
+          const projectJsonPath = path16.join(
             process.env.HOME || "",
             ".prjct-cli",
             "projects",
             projectId,
             "project.json"
           );
-          if (!fs15.existsSync(projectJsonPath)) return null;
-          const project = JSON.parse(fs15.readFileSync(projectJsonPath, "utf-8"));
+          if (!fs16.existsSync(projectJsonPath)) return null;
+          const project = JSON.parse(fs16.readFileSync(projectJsonPath, "utf-8"));
           return project.hooks || null;
         } catch {
           return null;
@@ -5898,17 +6102,17 @@ var init_hooks_service = __esm({
         const projectId = await config_manager_default.getProjectId(projectPath);
         if (!projectId) return;
         try {
-          const projectJsonPath = path15.join(
+          const projectJsonPath = path16.join(
             process.env.HOME || "",
             ".prjct-cli",
             "projects",
             projectId,
             "project.json"
           );
-          if (!fs15.existsSync(projectJsonPath)) return;
-          const project = JSON.parse(fs15.readFileSync(projectJsonPath, "utf-8"));
+          if (!fs16.existsSync(projectJsonPath)) return;
+          const project = JSON.parse(fs16.readFileSync(projectJsonPath, "utf-8"));
           project.hooks = config;
-          fs15.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          fs16.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
         } catch {
         }
       }
@@ -5925,8 +6129,8 @@ __export(doctor_service_exports, {
   doctorService: () => doctorService
 });
 import { execSync as execSync2 } from "node:child_process";
-import fs16 from "node:fs/promises";
-import path16 from "node:path";
+import fs17 from "node:fs/promises";
+import path17 from "node:path";
 import chalk5 from "chalk";
 var DoctorService, doctorService;
 var init_doctor_service = __esm({
@@ -6039,9 +6243,9 @@ var init_doctor_service = __esm({
         return checks;
       }
       async checkPrjctConfig() {
-        const configPath = path16.join(this.projectPath, ".prjct", "prjct.config.json");
+        const configPath = path17.join(this.projectPath, ".prjct", "prjct.config.json");
         try {
-          await fs16.access(configPath);
+          await fs17.access(configPath);
           return {
             name: "prjct config",
             status: "ok",
@@ -6063,9 +6267,9 @@ var init_doctor_service = __esm({
             message: "project not initialized"
           };
         }
-        const claudePath = path16.join(this.globalPath, "context", "CLAUDE.md");
+        const claudePath = path17.join(this.globalPath, "context", "CLAUDE.md");
         try {
-          const stat = await fs16.stat(claudePath);
+          const stat = await fs17.stat(claudePath);
           const ageMs = Date.now() - stat.mtimeMs;
           const ageHours = Math.floor(ageMs / (1e3 * 60 * 60));
           const ageDays = Math.floor(ageHours / 24);
@@ -6137,9 +6341,9 @@ var init_doctor_service = __esm({
             message: "project not initialized"
           };
         }
-        const statePath = path16.join(this.globalPath, "storage", "state.json");
+        const statePath = path17.join(this.globalPath, "storage", "state.json");
         try {
-          const content = await fs16.readFile(statePath, "utf-8");
+          const content = await fs17.readFile(statePath, "utf-8");
           const state = JSON.parse(content);
           if (state.currentTask) {
             return {
@@ -6236,13 +6440,13 @@ var init_doctor_service = __esm({
 });
 
 // core/infrastructure/command-installer.ts
-import fs17 from "node:fs/promises";
+import fs18 from "node:fs/promises";
 import os5 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 async function loadModuleConfig() {
   try {
-    const configPath = path17.join(getPackageRoot(), "templates/global/modules/module-config.json");
-    const content = await fs17.readFile(configPath, "utf-8");
+    const configPath = path18.join(getPackageRoot(), "templates/global/modules/module-config.json");
+    const content = await fs18.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -6250,18 +6454,18 @@ async function loadModuleConfig() {
 }
 async function composeGlobalTemplate(profile) {
   const config = await loadModuleConfig();
-  const modulesDir = path17.join(getPackageRoot(), "templates/global/modules");
+  const modulesDir = path18.join(getPackageRoot(), "templates/global/modules");
   if (!config) {
-    const legacyPath = path17.join(getPackageRoot(), "templates/global/CLAUDE.md");
-    return fs17.readFile(legacyPath, "utf-8");
+    const legacyPath = path18.join(getPackageRoot(), "templates/global/CLAUDE.md");
+    return fs18.readFile(legacyPath, "utf-8");
   }
   const profileName = profile || config.default;
   const selectedProfile = config.profiles[profileName];
   if (!selectedProfile) {
     const defaultProfile = config.profiles[config.default];
     if (!defaultProfile) {
-      const legacyPath = path17.join(getPackageRoot(), "templates/global/CLAUDE.md");
-      return fs17.readFile(legacyPath, "utf-8");
+      const legacyPath = path18.join(getPackageRoot(), "templates/global/CLAUDE.md");
+      return fs18.readFile(legacyPath, "utf-8");
     }
   }
   const modules = (selectedProfile || config.profiles[config.default]).modules;
@@ -6269,8 +6473,8 @@ async function composeGlobalTemplate(profile) {
   parts.push("<!-- prjct:start - DO NOT REMOVE THIS MARKER -->");
   for (const moduleName of modules) {
     try {
-      const modulePath = path17.join(modulesDir, moduleName);
-      const content = await fs17.readFile(modulePath, "utf-8");
+      const modulePath = path18.join(modulesDir, moduleName);
+      const content = await fs18.readFile(modulePath, "utf-8");
       parts.push("");
       parts.push(content);
     } catch {
@@ -6284,16 +6488,16 @@ async function composeGlobalTemplate(profile) {
 }
 async function installDocs() {
   try {
-    const docsDir = path17.join(os5.homedir(), ".prjct-cli", "docs");
-    const templateDocsDir = path17.join(getPackageRoot(), "templates/global/docs");
-    await fs17.mkdir(docsDir, { recursive: true });
-    const docFiles = await fs17.readdir(templateDocsDir);
+    const docsDir = path18.join(os5.homedir(), ".prjct-cli", "docs");
+    const templateDocsDir = path18.join(getPackageRoot(), "templates/global/docs");
+    await fs18.mkdir(docsDir, { recursive: true });
+    const docFiles = await fs18.readdir(templateDocsDir);
     for (const file of docFiles) {
       if (file.endsWith(".md")) {
-        const srcPath = path17.join(templateDocsDir, file);
-        const destPath = path17.join(docsDir, file);
-        const content = await fs17.readFile(srcPath, "utf-8");
-        await fs17.writeFile(destPath, content, "utf-8");
+        const srcPath = path18.join(templateDocsDir, file);
+        const destPath = path18.join(docsDir, file);
+        const content = await fs18.readFile(srcPath, "utf-8");
+        await fs18.writeFile(destPath, content, "utf-8");
       }
     }
     return { success: true };
@@ -6314,9 +6518,9 @@ async function installGlobalConfig2() {
     };
   }
   try {
-    await fs17.mkdir(activeProvider.configDir, { recursive: true });
-    const globalConfigPath = path17.join(activeProvider.configDir, activeProvider.contextFile);
-    const templatePath = path17.join(
+    await fs18.mkdir(activeProvider.configDir, { recursive: true });
+    const globalConfigPath = path18.join(activeProvider.configDir, activeProvider.contextFile);
+    const templatePath = path18.join(
       getPackageRoot(),
       "templates",
       "global",
@@ -6324,18 +6528,18 @@ async function installGlobalConfig2() {
     );
     let templateContent = "";
     try {
-      templateContent = await fs17.readFile(templatePath, "utf-8");
+      templateContent = await fs18.readFile(templatePath, "utf-8");
     } catch (_error) {
       if (providerName === "claude") {
         try {
           templateContent = await composeGlobalTemplate("standard");
         } catch {
-          const fallbackTemplatePath = path17.join(getPackageRoot(), "templates/global/CLAUDE.md");
-          templateContent = await fs17.readFile(fallbackTemplatePath, "utf-8");
+          const fallbackTemplatePath = path18.join(getPackageRoot(), "templates/global/CLAUDE.md");
+          templateContent = await fs18.readFile(fallbackTemplatePath, "utf-8");
         }
       } else {
-        const fallbackTemplatePath = path17.join(getPackageRoot(), "templates/global/CLAUDE.md");
-        templateContent = await fs17.readFile(fallbackTemplatePath, "utf-8");
+        const fallbackTemplatePath = path18.join(getPackageRoot(), "templates/global/CLAUDE.md");
+        templateContent = await fs18.readFile(fallbackTemplatePath, "utf-8");
         if (providerName === "gemini") {
           templateContent = templateContent.replace(/Claude/g, "Gemini");
         }
@@ -6344,7 +6548,7 @@ async function installGlobalConfig2() {
     let existingContent = "";
     let fileExists2 = false;
     try {
-      existingContent = await fs17.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs18.readFile(globalConfigPath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -6354,7 +6558,7 @@ async function installGlobalConfig2() {
       }
     }
     if (!fileExists2) {
-      await fs17.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs18.writeFile(globalConfigPath, templateContent, "utf-8");
       return {
         success: true,
         action: "created",
@@ -6368,7 +6572,7 @@ async function installGlobalConfig2() {
         const updatedContent = `${existingContent}
 
 ${templateContent}`;
-        await fs17.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await fs18.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "appended",
@@ -6384,7 +6588,7 @@ ${templateContent}`;
           templateContent.indexOf(endMarker) + endMarker.length
         );
         const updatedContent = beforeMarker + prjctSection + afterMarker;
-        await fs17.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await fs18.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "updated",
@@ -6404,14 +6608,14 @@ function getProviderPaths() {
   const homeDir = os5.homedir();
   return {
     claude: {
-      commands: path17.join(homeDir, ".claude", "commands", "p"),
-      config: path17.join(homeDir, ".claude"),
-      router: path17.join(homeDir, ".claude", "commands", "p.md")
+      commands: path18.join(homeDir, ".claude", "commands", "p"),
+      config: path18.join(homeDir, ".claude"),
+      router: path18.join(homeDir, ".claude", "commands", "p.md")
     },
     gemini: {
-      commands: path17.join(homeDir, ".gemini", "commands"),
-      config: path17.join(homeDir, ".gemini"),
-      router: path17.join(homeDir, ".gemini", "commands", "p.toml")
+      commands: path18.join(homeDir, ".gemini", "commands"),
+      config: path18.join(homeDir, ".gemini"),
+      router: path18.join(homeDir, ".gemini", "commands", "p.toml")
     }
   };
 }
@@ -6438,19 +6642,19 @@ var init_command_installer = __esm({
         const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
         const activeProvider = aiProvider.getActiveProvider();
         if (activeProvider.name === "gemini") {
-          this.claudeCommandsPath = path17.join(activeProvider.configDir, "commands");
+          this.claudeCommandsPath = path18.join(activeProvider.configDir, "commands");
         } else {
-          this.claudeCommandsPath = path17.join(activeProvider.configDir, "commands", "p");
+          this.claudeCommandsPath = path18.join(activeProvider.configDir, "commands", "p");
         }
         this.claudeConfigPath = activeProvider.configDir;
-        this.templatesDir = path17.join(getPackageRoot(), "templates", "commands");
+        this.templatesDir = path18.join(getPackageRoot(), "templates", "commands");
       }
       /**
        * Detect if active provider is installed
        */
       async detectActiveProvider() {
         try {
-          await fs17.access(this.claudeConfigPath);
+          await fs18.access(this.claudeConfigPath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -6470,7 +6674,7 @@ var init_command_installer = __esm({
        */
       async getCommandFiles() {
         try {
-          const files = await fs17.readdir(this.templatesDir);
+          const files = await fs18.readdir(this.templatesDir);
           return files.filter((f) => f.endsWith(".md"));
         } catch (_error) {
           return [
@@ -6511,16 +6715,16 @@ var init_command_installer = __esm({
         }
         try {
           await this.installRouter();
-          await fs17.mkdir(this.claudeCommandsPath, { recursive: true });
+          await fs18.mkdir(this.claudeCommandsPath, { recursive: true });
           const commandFiles = await this.getCommandFiles();
           const installed = [];
           const errors = [];
           for (const file of commandFiles) {
             try {
-              const sourcePath = path17.join(this.templatesDir, file);
-              const destPath = path17.join(this.claudeCommandsPath, file);
-              const content = await fs17.readFile(sourcePath, "utf-8");
-              await fs17.writeFile(destPath, content, "utf-8");
+              const sourcePath = path18.join(this.templatesDir, file);
+              const destPath = path18.join(this.claudeCommandsPath, file);
+              const content = await fs18.readFile(sourcePath, "utf-8");
+              await fs18.writeFile(destPath, content, "utf-8");
               installed.push(file.replace(".md", ""));
             } catch (error) {
               errors.push({ file, error: error.message });
@@ -6549,8 +6753,8 @@ var init_command_installer = __esm({
           const errors = [];
           for (const file of commandFiles) {
             try {
-              const filePath = path17.join(this.claudeCommandsPath, file);
-              await fs17.unlink(filePath);
+              const filePath = path18.join(this.claudeCommandsPath, file);
+              await fs18.unlink(filePath);
               uninstalled.push(file.replace(".md", ""));
             } catch (error) {
               if (error.code !== "ENOENT") {
@@ -6559,7 +6763,7 @@ var init_command_installer = __esm({
             }
           }
           try {
-            await fs17.rmdir(this.claudeCommandsPath);
+            await fs18.rmdir(this.claudeCommandsPath);
           } catch (_error) {
           }
           return {
@@ -6586,8 +6790,8 @@ var init_command_installer = __esm({
           };
         }
         try {
-          await fs17.access(this.claudeCommandsPath);
-          const files = await fs17.readdir(this.claudeCommandsPath);
+          await fs18.access(this.claudeCommandsPath);
+          const files = await fs18.readdir(this.claudeCommandsPath);
           const installedCommands = files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
           return {
             installed: installedCommands.length > 0,
@@ -6634,8 +6838,8 @@ var init_command_installer = __esm({
        */
       async verifyTemplate(commandName) {
         try {
-          const templatePath = path17.join(this.templatesDir, `${commandName}.md`);
-          await fs17.access(templatePath);
+          const templatePath = path18.join(this.templatesDir, `${commandName}.md`);
+          await fs18.access(templatePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -6653,11 +6857,11 @@ var init_command_installer = __esm({
         const activeProvider = aiProvider.getActiveProvider();
         const routerFile = activeProvider.name === "gemini" ? "p.toml" : "p.md";
         try {
-          const routerSource = path17.join(this.templatesDir, routerFile);
-          const routerDest = path17.join(activeProvider.configDir, "commands", routerFile);
-          await fs17.mkdir(path17.dirname(routerDest), { recursive: true });
-          const content = await fs17.readFile(routerSource, "utf-8");
-          await fs17.writeFile(routerDest, content, "utf-8");
+          const routerSource = path18.join(this.templatesDir, routerFile);
+          const routerDest = path18.join(activeProvider.configDir, "commands", routerFile);
+          await fs18.mkdir(path18.dirname(routerDest), { recursive: true });
+          const content = await fs18.readFile(routerSource, "utf-8");
+          await fs18.writeFile(routerDest, content, "utf-8");
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -6673,14 +6877,14 @@ var init_command_installer = __esm({
       async removeLegacyCommands() {
         const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
         const activeProvider = aiProvider.getActiveProvider();
-        const commandsRoot = path17.join(activeProvider.configDir, "commands");
+        const commandsRoot = path18.join(activeProvider.configDir, "commands");
         let removed = 0;
         try {
-          const files = await fs17.readdir(commandsRoot);
+          const files = await fs18.readdir(commandsRoot);
           const legacyFiles = files.filter((f) => f.startsWith("p.") && f.endsWith(".md"));
           for (const file of legacyFiles) {
             try {
-              await fs17.unlink(path17.join(commandsRoot, file));
+              await fs18.unlink(path18.join(commandsRoot, file));
               removed++;
             } catch {
             }
@@ -6705,11 +6909,11 @@ var init_command_installer = __esm({
         }
         try {
           await this.installRouter();
-          await fs17.mkdir(this.claudeCommandsPath, { recursive: true });
+          await fs18.mkdir(this.claudeCommandsPath, { recursive: true });
           const templateFiles = await this.getCommandFiles();
           let installedFiles = [];
           try {
-            installedFiles = await fs17.readdir(this.claudeCommandsPath);
+            installedFiles = await fs18.readdir(this.claudeCommandsPath);
             installedFiles = installedFiles.filter((f) => f.endsWith(".md"));
           } catch (error) {
             if (isNotFoundError(error)) {
@@ -6727,11 +6931,11 @@ var init_command_installer = __esm({
           };
           for (const file of templateFiles) {
             try {
-              const sourcePath = path17.join(this.templatesDir, file);
-              const destPath = path17.join(this.claudeCommandsPath, file);
+              const sourcePath = path18.join(this.templatesDir, file);
+              const destPath = path18.join(this.claudeCommandsPath, file);
               const exists = installedFiles.includes(file);
-              const content = await fs17.readFile(sourcePath, "utf-8");
-              await fs17.writeFile(destPath, content, "utf-8");
+              const content = await fs18.readFile(sourcePath, "utf-8");
+              await fs18.writeFile(destPath, content, "utf-8");
               if (!exists) {
                 results.added++;
               } else {
@@ -7114,7 +7318,7 @@ var init_chain_of_thought = __esm({
 });
 
 // core/agentic/context-builder.ts
-import fs18 from "node:fs/promises";
+import fs19 from "node:fs/promises";
 var ContextBuilder, contextBuilder, context_builder_default;
 var init_context_builder = __esm({
   "core/agentic/context-builder.ts"() {
@@ -7193,7 +7397,7 @@ var init_context_builder = __esm({
         for (const [, filePath] of filteredEntries) {
           if (this._cache.has(filePath)) {
             try {
-              const stat = await fs18.stat(filePath);
+              const stat = await fs19.stat(filePath);
               const cachedMtime = this._mtimes.get(filePath);
               if (!cachedMtime || stat.mtimeMs > cachedMtime) {
                 this._cache.delete(filePath);
@@ -7221,8 +7425,8 @@ var init_context_builder = __esm({
           const readPromises = uncachedEntries.map(async ([key, filePath]) => {
             try {
               const [content, stat] = await Promise.all([
-                fs18.readFile(filePath, "utf-8"),
-                fs18.stat(filePath)
+                fs19.readFile(filePath, "utf-8"),
+                fs19.stat(filePath)
               ]);
               return { key, filePath, content, mtime: stat.mtimeMs };
             } catch (error) {
@@ -7296,7 +7500,7 @@ var init_context_builder = __esm({
         if (uncachedPaths.length > 0) {
           const readPromises = uncachedPaths.map(async (filePath) => {
             try {
-              const content = await fs18.readFile(filePath, "utf-8");
+              const content = await fs19.readFile(filePath, "utf-8");
               return { filePath, content };
             } catch (error) {
               if (isNotFoundError(error)) {
@@ -7330,7 +7534,7 @@ var init_context_builder = __esm({
        */
       async fileExists(filePath) {
         try {
-          await fs18.access(filePath);
+          await fs19.access(filePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -7357,9 +7561,9 @@ var init_context_builder = __esm({
 
 // core/agentic/ground-truth.ts
 import { exec as exec5 } from "node:child_process";
-import fs19 from "node:fs/promises";
+import fs20 from "node:fs/promises";
 import os6 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 import { promisify as promisify5 } from "node:util";
 function formatDuration2(ms) {
   const hours = Math.floor(ms / (1e3 * 60 * 60));
@@ -7396,7 +7600,7 @@ async function verifyDone(context2) {
   const actual = {};
   const nowPath = context2.paths.now;
   try {
-    const nowContent = await fs19.readFile(nowPath, "utf-8");
+    const nowContent = await fs20.readFile(nowPath, "utf-8");
     actual.nowExists = true;
     actual.nowContent = nowContent.trim();
     actual.nowLength = nowContent.length;
@@ -7424,7 +7628,7 @@ async function verifyDone(context2) {
   }
   const nextPath = context2.paths.next;
   try {
-    const nextContent = await fs19.readFile(nextPath, "utf-8");
+    const nextContent = await fs20.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[ \]/g) || [];
     actual.pendingTasks = tasks.length;
@@ -7438,7 +7642,7 @@ async function verifyDone(context2) {
   }
   const metricsPath = context2.paths.metrics;
   try {
-    await fs19.access(path18.dirname(metricsPath), fs19.constants.W_OK);
+    await fs20.access(path19.dirname(metricsPath), fs20.constants.W_OK);
     actual.metricsWritable = true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -7472,9 +7676,9 @@ async function verifyShip(context2) {
   } catch (_error) {
     actual.gitAvailable = false;
   }
-  const pkgPath = path18.join(context2.projectPath, "package.json");
+  const pkgPath = path19.join(context2.projectPath, "package.json");
   try {
-    const pkgContent = await fs19.readFile(pkgPath, "utf-8");
+    const pkgContent = await fs20.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     actual.currentVersion = pkg.version;
     actual.hasPackageJson = true;
@@ -7490,7 +7694,7 @@ async function verifyShip(context2) {
   }
   const shippedPath = context2.paths.shipped;
   try {
-    const shippedContent = await fs19.readFile(shippedPath, "utf-8");
+    const shippedContent = await fs20.readFile(shippedPath, "utf-8");
     actual.shippedExists = true;
     const featureName = context2.params.feature || context2.params.description;
     if (featureName) {
@@ -7510,7 +7714,7 @@ async function verifyShip(context2) {
   }
   if (actual.hasPackageJson) {
     try {
-      const pkgContent = await fs19.readFile(pkgPath, "utf-8");
+      const pkgContent = await fs20.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       actual.hasTestScript = !!pkg.scripts?.test;
     } catch (error) {
@@ -7534,7 +7738,7 @@ async function verifyFeature(context2) {
   const actual = {};
   const nextPath = context2.paths.next;
   try {
-    const nextContent = await fs19.readFile(nextPath, "utf-8");
+    const nextContent = await fs20.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[[ x]\]/g) || [];
     actual.taskCount = tasks.length;
@@ -7553,7 +7757,7 @@ async function verifyFeature(context2) {
   }
   const roadmapPath = context2.paths.roadmap;
   try {
-    const roadmapContent = await fs19.readFile(roadmapPath, "utf-8");
+    const roadmapContent = await fs20.readFile(roadmapPath, "utf-8");
     actual.roadmapExists = true;
     const featureName = context2.params.description || context2.params.feature;
     if (featureName) {
@@ -7572,7 +7776,7 @@ async function verifyFeature(context2) {
   }
   const nowPath = context2.paths.now;
   try {
-    const nowContent = await fs19.readFile(nowPath, "utf-8");
+    const nowContent = await fs20.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");
@@ -7597,7 +7801,7 @@ async function verifyNow(context2) {
   const actual = {};
   const nowPath = context2.paths.now;
   try {
-    const nowContent = await fs19.readFile(nowPath, "utf-8");
+    const nowContent = await fs20.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);
@@ -7617,7 +7821,7 @@ async function verifyNow(context2) {
   }
   const nextPath = context2.paths.next;
   try {
-    const nextContent = await fs19.readFile(nextPath, "utf-8");
+    const nextContent = await fs20.readFile(nextPath, "utf-8");
     const pendingTasks = (nextContent.match(/- \[ \]/g) || []).length;
     actual.pendingTasks = pendingTasks;
     if (!context2.params.task && pendingTasks > 0) {
@@ -7641,9 +7845,9 @@ async function verifyInit(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path18.join(context2.projectPath, ".prjct/prjct.config.json");
+  const configPath = path19.join(context2.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs19.readFile(configPath, "utf-8");
+    const configContent = await fs20.readFile(configPath, "utf-8");
     actual.alreadyInitialized = true;
     actual.existingConfig = JSON.parse(configContent);
     warnings.push("Project already initialized");
@@ -7658,14 +7862,14 @@ async function verifyInit(context2) {
       throw error;
     }
   }
-  const globalPath = path18.join(os6.homedir(), ".prjct-cli");
+  const globalPath = path19.join(os6.homedir(), ".prjct-cli");
   try {
-    await fs19.access(globalPath, fs19.constants.W_OK);
+    await fs20.access(globalPath, fs20.constants.W_OK);
     actual.globalPathWritable = true;
   } catch (error) {
     if (isNotFoundError(error)) {
       try {
-        await fs19.mkdir(globalPath, { recursive: true });
+        await fs20.mkdir(globalPath, { recursive: true });
         actual.globalPathWritable = true;
         actual.globalPathCreated = true;
       } catch (_mkdirError) {
@@ -7690,9 +7894,9 @@ async function verifySync(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path18.join(context2.projectPath, ".prjct/prjct.config.json");
+  const configPath = path19.join(context2.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs19.readFile(configPath, "utf-8");
+    const configContent = await fs20.readFile(configPath, "utf-8");
     actual.hasConfig = true;
     actual.config = JSON.parse(configContent);
   } catch (error) {
@@ -7711,9 +7915,9 @@ async function verifySync(context2) {
     }
   }
   const projectId = actual.config?.projectId;
-  const globalProjectPath = path18.join(os6.homedir(), ".prjct-cli/projects", projectId || "");
+  const globalProjectPath = path19.join(os6.homedir(), ".prjct-cli/projects", projectId || "");
   try {
-    await fs19.access(globalProjectPath);
+    await fs20.access(globalProjectPath);
     actual.globalStorageExists = true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -7739,7 +7943,7 @@ async function verifyAnalyze(context2) {
   actual.detectedFiles = [];
   for (const file of files) {
     try {
-      await fs19.access(path18.join(context2.projectPath, file));
+      await fs20.access(path19.join(context2.projectPath, file));
       actual.detectedFiles.push(file);
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -7755,7 +7959,7 @@ async function verifyAnalyze(context2) {
   actual.detectedSrcDirs = [];
   for (const dir of srcDirs) {
     try {
-      const stat = await fs19.stat(path18.join(context2.projectPath, dir));
+      const stat = await fs20.stat(path19.join(context2.projectPath, dir));
       if (stat.isDirectory()) {
         ;
         actual.detectedSrcDirs.push(dir);
@@ -7780,9 +7984,9 @@ async function verifySpec(context2) {
   const actual = {};
   const specsPath = context2.paths.specs;
   try {
-    await fs19.access(specsPath);
+    await fs20.access(specsPath);
     actual.specsExists = true;
-    const files = await fs19.readdir(specsPath);
+    const files = await fs20.readdir(specsPath);
     actual.existingSpecs = files.filter((f) => f.endsWith(".md"));
     actual.specCount = actual.existingSpecs.length;
   } catch (error) {
@@ -9183,8 +9387,8 @@ var init_schemas2 = __esm({
 
 // core/utils/jsonl-helper.ts
 import fsSync from "node:fs";
-import fs20 from "node:fs/promises";
-import path19 from "node:path";
+import fs21 from "node:fs/promises";
+import path20 from "node:path";
 import readline from "node:readline";
 function parseJsonLines(content) {
   const lines = content.split("\n").filter((line) => line.trim());
@@ -9203,7 +9407,7 @@ function stringifyJsonLines(objects) {
 }
 async function readJsonLines(filePath) {
   try {
-    const content = await fs20.readFile(filePath, "utf-8");
+    const content = await fs21.readFile(filePath, "utf-8");
     return parseJsonLines(content);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -9214,16 +9418,16 @@ async function readJsonLines(filePath) {
 }
 async function writeJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs20.writeFile(filePath, content, "utf-8");
+  await fs21.writeFile(filePath, content, "utf-8");
 }
 async function appendJsonLine(filePath, object) {
   const line = `${JSON.stringify(object)}
 `;
-  await fs20.appendFile(filePath, line, "utf-8");
+  await fs21.appendFile(filePath, line, "utf-8");
 }
 async function appendJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs20.appendFile(filePath, content, "utf-8");
+  await fs21.appendFile(filePath, content, "utf-8");
 }
 async function filterJsonLines(filePath, predicate) {
   const entries = await readJsonLines(filePath);
@@ -9231,7 +9435,7 @@ async function filterJsonLines(filePath, predicate) {
 }
 async function countJsonLines(filePath) {
   try {
-    const content = await fs20.readFile(filePath, "utf-8");
+    const content = await fs21.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return lines.length;
   } catch (error) {
@@ -9290,7 +9494,7 @@ async function readJsonLinesStreaming(filePath, maxLines = 1e3) {
 }
 async function getFileSizeMB(filePath) {
   try {
-    const stats = await fs20.stat(filePath);
+    const stats = await fs21.stat(filePath);
     return stats.size / (1024 * 1024);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -9305,13 +9509,13 @@ async function rotateJsonLinesIfNeeded(filePath, maxSizeMB = 10) {
     return false;
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const dir = path19.dirname(filePath);
-  const ext = path19.extname(filePath);
-  const base = path19.basename(filePath, ext);
-  const archivePath = path19.join(dir, `${base}-${timestamp}${ext}`);
-  await fs20.rename(filePath, archivePath);
+  const dir = path20.dirname(filePath);
+  const ext = path20.extname(filePath);
+  const base = path20.basename(filePath, ext);
+  const archivePath = path20.join(dir, `${base}-${timestamp}${ext}`);
+  await fs21.rename(filePath, archivePath);
   console.log(
-    `\u{1F4E6} Rotated ${path19.basename(filePath)} (${sizeMB.toFixed(1)}MB) \u2192 ${path19.basename(archivePath)}`
+    `\u{1F4E6} Rotated ${path20.basename(filePath)} (${sizeMB.toFixed(1)}MB) \u2192 ${path20.basename(archivePath)}`
   );
   return true;
 }
@@ -9324,7 +9528,7 @@ async function checkFileSizeWarning(filePath, warnThresholdMB = 50) {
   const isLarge = sizeMB > warnThresholdMB;
   if (isLarge) {
     console.warn(
-      `\u26A0\uFE0F  Large file detected: ${path19.basename(filePath)} (${sizeMB.toFixed(1)}MB). Reading may use significant memory.`
+      `\u26A0\uFE0F  Large file detected: ${path20.basename(filePath)} (${sizeMB.toFixed(1)}MB). Reading may use significant memory.`
     );
   }
   return { sizeMB, isLarge };
@@ -9408,8 +9612,8 @@ var init_memory = __esm({
 });
 
 // core/agentic/memory-system.ts
-import fs21 from "node:fs/promises";
-import path20 from "node:path";
+import fs22 from "node:fs/promises";
+import path21 from "node:path";
 var CachedStore, SessionStore, HistoryStore, PatternStore, SemanticMemories, MemorySystem, memorySystem, memory_system_default;
 var init_memory_system = __esm({
   "core/agentic/memory-system.ts"() {
@@ -9439,12 +9643,12 @@ var init_memory_system = __esm({
        * Get full path for the store file
        */
       getPath(projectId) {
-        const basePath = path20.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
+        const basePath = path21.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
         const subdir = this.getSubdirectory();
         if (subdir) {
-          return path20.join(basePath, subdir, this.getFilename());
+          return path21.join(basePath, subdir, this.getFilename());
         }
-        return path20.join(basePath, this.getFilename());
+        return path21.join(basePath, this.getFilename());
       }
       /**
        * Load data from disk (with caching)
@@ -9456,7 +9660,7 @@ var init_memory_system = __esm({
         }
         const filePath = this.getPath(projectId);
         try {
-          const content = await fs21.readFile(filePath, "utf-8");
+          const content = await fs22.readFile(filePath, "utf-8");
           this._data = JSON.parse(content);
           this.afterLoad(this._data);
         } catch (error) {
@@ -9482,8 +9686,8 @@ var init_memory_system = __esm({
       async save(projectId) {
         if (!this._data) return;
         const filePath = this.getPath(projectId);
-        await fs21.mkdir(path20.dirname(filePath), { recursive: true });
-        await fs21.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
+        await fs22.mkdir(path21.dirname(filePath), { recursive: true });
+        await fs22.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
       }
       /**
        * Get cached data without loading (may be null)
@@ -9549,7 +9753,7 @@ 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 path20.join(
+        return path21.join(
           path_manager_default.getGlobalProjectPath(projectId),
           "memory",
           "sessions",
@@ -9559,7 +9763,7 @@ var init_memory_system = __esm({
       }
       async appendHistory(projectId, entry) {
         const sessionPath = this._getSessionPath(projectId);
-        await ensureDir(path20.dirname(sessionPath));
+        await ensureDir(path21.dirname(sessionPath));
         const logEntry = {
           ts: getTimestamp(),
           ...entry,
@@ -10449,8 +10653,8 @@ var init_ideas_storage = __esm({
 
 // core/storage/index-storage.ts
 import crypto4 from "node:crypto";
-import fs22 from "node:fs/promises";
-import path21 from "node:path";
+import fs23 from "node:fs/promises";
+import path22 from "node:path";
 function getDefaultChecksums() {
   return {
     version: INDEX_VERSION,
@@ -10475,14 +10679,14 @@ var init_index_storage = __esm({
        * Get the index directory path for a project
        */
       getIndexPath(projectId) {
-        return path21.join(path_manager_default.getGlobalProjectPath(projectId), "index");
+        return path22.join(path_manager_default.getGlobalProjectPath(projectId), "index");
       }
       /**
        * Ensure index directory exists
        */
       async ensureIndexDir(projectId) {
         const indexPath = this.getIndexPath(projectId);
-        await fs22.mkdir(indexPath, { recursive: true });
+        await fs23.mkdir(indexPath, { recursive: true });
         return indexPath;
       }
       // ==========================================================================
@@ -10492,9 +10696,9 @@ var init_index_storage = __esm({
        * Read the project index
        */
       async readIndex(projectId) {
-        const filePath = path21.join(this.getIndexPath(projectId), "project-index.json");
+        const filePath = path22.join(this.getIndexPath(projectId), "project-index.json");
         try {
-          const content = await fs22.readFile(filePath, "utf-8");
+          const content = await fs23.readFile(filePath, "utf-8");
           const index = JSON.parse(content);
           if (index.version !== INDEX_VERSION) {
             return null;
@@ -10512,8 +10716,8 @@ var init_index_storage = __esm({
        */
       async writeIndex(projectId, index) {
         await this.ensureIndexDir(projectId);
-        const filePath = path21.join(this.getIndexPath(projectId), "project-index.json");
-        await fs22.writeFile(filePath, JSON.stringify(index, null, 2), "utf-8");
+        const filePath = path22.join(this.getIndexPath(projectId), "project-index.json");
+        await fs23.writeFile(filePath, JSON.stringify(index, null, 2), "utf-8");
       }
       /**
        * Check if index exists and is valid
@@ -10529,9 +10733,9 @@ var init_index_storage = __esm({
        * Read file checksums
        */
       async readChecksums(projectId) {
-        const filePath = path21.join(this.getIndexPath(projectId), "checksums.json");
+        const filePath = path22.join(this.getIndexPath(projectId), "checksums.json");
         try {
-          const content = await fs22.readFile(filePath, "utf-8");
+          const content = await fs23.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -10545,15 +10749,15 @@ var init_index_storage = __esm({
        */
       async writeChecksums(projectId, checksums) {
         await this.ensureIndexDir(projectId);
-        const filePath = path21.join(this.getIndexPath(projectId), "checksums.json");
-        await fs22.writeFile(filePath, JSON.stringify(checksums, null, 2), "utf-8");
+        const filePath = path22.join(this.getIndexPath(projectId), "checksums.json");
+        await fs23.writeFile(filePath, JSON.stringify(checksums, null, 2), "utf-8");
       }
       /**
        * Calculate checksum for a file
        */
       async calculateChecksum(filePath) {
         try {
-          const content = await fs22.readFile(filePath);
+          const content = await fs23.readFile(filePath);
           return crypto4.createHash("md5").update(content).digest("hex");
         } catch {
           return "";
@@ -10589,9 +10793,9 @@ var init_index_storage = __esm({
        * Read file scores
        */
       async readScores(projectId) {
-        const filePath = path21.join(this.getIndexPath(projectId), "file-scores.json");
+        const filePath = path22.join(this.getIndexPath(projectId), "file-scores.json");
         try {
-          const content = await fs22.readFile(filePath, "utf-8");
+          const content = await fs23.readFile(filePath, "utf-8");
           const data = JSON.parse(content);
           return data.scores || [];
         } catch (error) {
@@ -10606,13 +10810,13 @@ var init_index_storage = __esm({
        */
       async writeScores(projectId, scores) {
         await this.ensureIndexDir(projectId);
-        const filePath = path21.join(this.getIndexPath(projectId), "file-scores.json");
+        const filePath = path22.join(this.getIndexPath(projectId), "file-scores.json");
         const data = {
           version: INDEX_VERSION,
           lastUpdated: getTimestamp(),
           scores
         };
-        await fs22.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs23.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
       }
       // ==========================================================================
       // UTILITY METHODS
@@ -10623,8 +10827,8 @@ var init_index_storage = __esm({
       async clearIndex(projectId) {
         const indexPath = this.getIndexPath(projectId);
         try {
-          const files = await fs22.readdir(indexPath);
-          await Promise.all(files.map((file) => fs22.unlink(path21.join(indexPath, file))));
+          const files = await fs23.readdir(indexPath);
+          await Promise.all(files.map((file) => fs23.unlink(path22.join(indexPath, file))));
         } catch (error) {
           if (!isNotFoundError(error)) {
             throw error;
@@ -10650,9 +10854,9 @@ var init_index_storage = __esm({
        * Read discovered domains for a project
        */
       async readDomains(projectId) {
-        const filePath = path21.join(this.getIndexPath(projectId), "domains.json");
+        const filePath = path22.join(this.getIndexPath(projectId), "domains.json");
         try {
-          const content = await fs22.readFile(filePath, "utf-8");
+          const content = await fs23.readFile(filePath, "utf-8");
           const domains = JSON.parse(content);
           if (domains.version !== INDEX_VERSION) {
             return null;
@@ -10670,8 +10874,8 @@ var init_index_storage = __esm({
        */
       async writeDomains(projectId, domains) {
         await this.ensureIndexDir(projectId);
-        const filePath = path21.join(this.getIndexPath(projectId), "domains.json");
-        await fs22.writeFile(filePath, JSON.stringify(domains, null, 2), "utf-8");
+        const filePath = path22.join(this.getIndexPath(projectId), "domains.json");
+        await fs23.writeFile(filePath, JSON.stringify(domains, null, 2), "utf-8");
       }
       // ==========================================================================
       // CATEGORIES CACHE
@@ -10680,9 +10884,9 @@ var init_index_storage = __esm({
        * Read categories cache
        */
       async readCategories(projectId) {
-        const filePath = path21.join(this.getIndexPath(projectId), "categories-cache.json");
+        const filePath = path22.join(this.getIndexPath(projectId), "categories-cache.json");
         try {
-          const content = await fs22.readFile(filePath, "utf-8");
+          const content = await fs23.readFile(filePath, "utf-8");
           const cache2 = JSON.parse(content);
           if (cache2.version !== INDEX_VERSION) {
             return null;
@@ -10700,8 +10904,8 @@ var init_index_storage = __esm({
        */
       async writeCategories(projectId, cache2) {
         await this.ensureIndexDir(projectId);
-        const filePath = path21.join(this.getIndexPath(projectId), "categories-cache.json");
-        await fs22.writeFile(filePath, JSON.stringify(cache2, null, 2), "utf-8");
+        const filePath = path22.join(this.getIndexPath(projectId), "categories-cache.json");
+        await fs23.writeFile(filePath, JSON.stringify(cache2, null, 2), "utf-8");
       }
       /**
        * Get file categories for specific paths
@@ -11761,9 +11965,9 @@ var init_state_storage = __esm({
 });
 
 // core/storage/storage.ts
-import fs23 from "node:fs/promises";
+import fs24 from "node:fs/promises";
 import os7 from "node:os";
-import path22 from "node:path";
+import path23 from "node:path";
 function getStorage(projectId) {
   return new FileStorage(projectId);
 }
@@ -11781,7 +11985,7 @@ var init_storage = __esm({
       basePath;
       constructor(projectId) {
         this.projectId = projectId;
-        this.basePath = path22.join(os7.homedir(), ".prjct-cli/projects", projectId, "data");
+        this.basePath = path23.join(os7.homedir(), ".prjct-cli/projects", projectId, "data");
       }
       /**
        * Convert path array to file path
@@ -11790,17 +11994,17 @@ var init_storage = __esm({
        */
       pathToFile(pathArray) {
         if (pathArray.length === 1) {
-          return path22.join(this.basePath, `${pathArray[0]}.json`);
+          return path23.join(this.basePath, `${pathArray[0]}.json`);
         }
         const dir = `${pathArray[0]}s`;
         const rest = pathArray.slice(1);
         const filename = `${rest.join("/")}.json`;
-        return path22.join(this.basePath, dir, filename);
+        return path23.join(this.basePath, dir, filename);
       }
       async write(pathArray, data) {
         const filePath = this.pathToFile(pathArray);
-        await fs23.mkdir(path22.dirname(filePath), { recursive: true });
-        await fs23.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs24.mkdir(path23.dirname(filePath), { recursive: true });
+        await fs24.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
         eventBus.publish({
           type: inferEventType(pathArray, "write"),
           path: pathArray,
@@ -11815,7 +12019,7 @@ var init_storage = __esm({
       async read(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          const content = await fs23.readFile(filePath, "utf-8");
+          const content = await fs24.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -11825,9 +12029,9 @@ var init_storage = __esm({
         }
       }
       async list(prefix) {
-        const dir = path22.join(this.basePath, `${prefix[0]}s`);
+        const dir = path23.join(this.basePath, `${prefix[0]}s`);
         try {
-          const files = await fs23.readdir(dir);
+          const files = await fs24.readdir(dir);
           return files.filter((f) => f.endsWith(".json") && f !== "index.json").map((f) => [...prefix, f.replace(".json", "")]);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -11839,7 +12043,7 @@ var init_storage = __esm({
       async delete(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs23.unlink(filePath);
+          await fs24.unlink(filePath);
           eventBus.publish({
             type: inferEventType(pathArray, "delete"),
             path: pathArray,
@@ -11859,7 +12063,7 @@ var init_storage = __esm({
       async exists(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs23.access(filePath);
+          await fs24.access(filePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -11872,10 +12076,10 @@ var init_storage = __esm({
        * Update collection index
        */
       async updateIndex(collection, id, action) {
-        const indexPath = path22.join(this.basePath, `${collection}s`, "index.json");
+        const indexPath = path23.join(this.basePath, `${collection}s`, "index.json");
         let index = { ids: [], updatedAt: "" };
         try {
-          const content = await fs23.readFile(indexPath, "utf-8");
+          const content = await fs24.readFile(indexPath, "utf-8");
           index = JSON.parse(content);
         } catch (error) {
           if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
@@ -11888,8 +12092,8 @@ var init_storage = __esm({
           index.ids = index.ids.filter((i) => i !== id);
         }
         index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await fs23.mkdir(path22.dirname(indexPath), { recursive: true });
-        await fs23.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+        await fs24.mkdir(path23.dirname(indexPath), { recursive: true });
+        await fs24.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
       }
     };
     __name(getStorage, "getStorage");
@@ -11912,8 +12116,8 @@ var init_storage2 = __esm({
 });
 
 // core/agentic/template-loader.ts
-import fs24 from "node:fs/promises";
-import path23 from "node:path";
+import fs25 from "node:fs/promises";
+import path24 from "node:path";
 function updateLruOrder(key) {
   const index = cacheOrder.indexOf(key);
   if (index > -1) cacheOrder.splice(index, 1);
@@ -11951,9 +12155,9 @@ async function load(commandName) {
     updateLruOrder(commandName);
     return cache.get(commandName);
   }
-  const templatePath = path23.join(TEMPLATES_DIR, `${commandName}.md`);
+  const templatePath = path24.join(TEMPLATES_DIR, `${commandName}.md`);
   try {
-    const rawContent = await fs24.readFile(templatePath, "utf-8");
+    const rawContent = await fs25.readFile(templatePath, "utf-8");
     const parsed = parseFrontmatter(rawContent);
     evictLru();
     cache.set(commandName, parsed);
@@ -11976,7 +12180,7 @@ var init_template_loader = __esm({
   "core/agentic/template-loader.ts"() {
     "use strict";
     init_errors();
-    TEMPLATES_DIR = path23.join(__dirname, "..", "..", "templates", "commands");
+    TEMPLATES_DIR = path24.join(__dirname, "..", "..", "templates", "commands");
     MAX_CACHE_SIZE = 50;
     cache = /* @__PURE__ */ new Map();
     cacheOrder = [];
@@ -11996,9 +12200,9 @@ var init_template_loader = __esm({
 });
 
 // core/agentic/orchestrator-executor.ts
-import fs25 from "node:fs/promises";
+import fs26 from "node:fs/promises";
 import os8 from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 var DOMAIN_KEYWORDS2, DOMAIN_DEPENDENCY_ORDER, OrchestratorExecutor, orchestratorExecutor, orchestrator_executor_default;
 var init_orchestrator_executor = __esm({
   "core/agentic/orchestrator-executor.ts"() {
@@ -12182,8 +12386,8 @@ var init_orchestrator_executor = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path24.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs25.readFile(analysisPath, "utf-8");
+          const analysisPath = path25.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs26.readFile(analysisPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error)) return null;
@@ -12247,8 +12451,8 @@ var init_orchestrator_executor = __esm({
        */
       async getAvailableAgentNames(globalPath) {
         try {
-          const agentsDir = path24.join(globalPath, "agents");
-          const files = await fs25.readdir(agentsDir);
+          const agentsDir = path25.join(globalPath, "agents");
+          const files = await fs26.readdir(agentsDir);
           return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
         } catch {
           return [];
@@ -12264,13 +12468,13 @@ var init_orchestrator_executor = __esm({
        */
       async loadAgents(domains, projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-        const agentsDir = path24.join(globalPath, "agents");
+        const agentsDir = path25.join(globalPath, "agents");
         const agentPromises = domains.map(async (domain) => {
           const possibleNames = [`${domain}.md`, `${domain}-agent.md`, `prjct-${domain}.md`];
           for (const fileName of possibleNames) {
-            const filePath = path24.join(agentsDir, fileName);
+            const filePath = path25.join(agentsDir, fileName);
             try {
-              const content = await fs25.readFile(filePath, "utf-8");
+              const content = await fs26.readFile(filePath, "utf-8");
               const { frontmatter, body } = this.parseAgentFile(content);
               return {
                 name: fileName.replace(".md", ""),
@@ -12309,7 +12513,7 @@ var init_orchestrator_executor = __esm({
        * Uses parallel file reads for performance (PRJ-110).
        */
       async loadSkills(agents) {
-        const skillsDir = path24.join(os8.homedir(), ".claude", "skills");
+        const skillsDir = path25.join(os8.homedir(), ".claude", "skills");
         const uniqueSkillNames = /* @__PURE__ */ new Set();
         for (const agent of agents) {
           for (const skillName of agent.skills) {
@@ -12318,14 +12522,14 @@ var init_orchestrator_executor = __esm({
         }
         const skillPromises = Array.from(uniqueSkillNames).map(
           async (skillName) => {
-            const flatPath = path24.join(skillsDir, `${skillName}.md`);
-            const subdirPath = path24.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path25.join(skillsDir, `${skillName}.md`);
+            const subdirPath = path25.join(skillsDir, skillName, "SKILL.md");
             try {
-              const content = await fs25.readFile(subdirPath, "utf-8");
+              const content = await fs26.readFile(subdirPath, "utf-8");
               return { name: skillName, content, filePath: subdirPath };
             } catch {
               try {
-                const content = await fs25.readFile(flatPath, "utf-8");
+                const content = await fs26.readFile(flatPath, "utf-8");
                 return { name: skillName, content, filePath: flatPath };
               } catch {
                 return null;
@@ -12932,7 +13136,7 @@ var init_types3 = __esm({
 });
 
 // core/outcomes/recorder.ts
-import path25 from "node:path";
+import path26 from "node:path";
 var OUTCOMES_DIR, OUTCOMES_FILE, OutcomeRecorder, outcomeRecorder, recorder_default;
 var init_recorder = __esm({
   "core/outcomes/recorder.ts"() {
@@ -12951,13 +13155,13 @@ var init_recorder = __esm({
        */
       getOutcomesDir(projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-        return path25.join(globalPath, OUTCOMES_DIR);
+        return path26.join(globalPath, OUTCOMES_DIR);
       }
       /**
        * Get outcomes file path for a project.
        */
       getOutcomesPath(projectId) {
-        return path25.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
+        return path26.join(this.getOutcomesDir(projectId), OUTCOMES_FILE);
       }
       /**
        * Record an outcome.
@@ -12968,7 +13172,7 @@ var init_recorder = __esm({
           id: generateUUID()
         };
         const outcomesPath = this.getOutcomesPath(projectId);
-        await ensureDir(path25.dirname(outcomesPath));
+        await ensureDir(path26.dirname(outcomesPath));
         await appendLine(outcomesPath, JSON.stringify(outcome));
         return outcome;
       }
@@ -13317,8 +13521,8 @@ var init_outcomes2 = __esm({
 });
 
 // core/agentic/prompt-builder.ts
-import fs26 from "node:fs";
-import path26 from "node:path";
+import fs27 from "node:fs";
+import path27 from "node:path";
 var PromptBuilder, promptBuilder, prompt_builder_default;
 var init_prompt_builder = __esm({
   "core/agentic/prompt-builder.ts"() {
@@ -13354,8 +13558,8 @@ var init_prompt_builder = __esm({
           return cached.content;
         }
         try {
-          if (fs26.existsSync(templatePath)) {
-            const content = fs26.readFileSync(templatePath, "utf-8");
+          if (fs27.existsSync(templatePath)) {
+            const content = fs27.readFileSync(templatePath, "utf-8");
             this._templateCache.set(templatePath, { content, loadedAt: now });
             return content;
           }
@@ -13394,7 +13598,7 @@ var init_prompt_builder = __esm({
        * These modules extend the base global CLAUDE.md for complex operations
        */
       loadModule(moduleName) {
-        const modulePath = path26.join(getPackageRoot(), "templates/global/modules", moduleName);
+        const modulePath = path27.join(getPackageRoot(), "templates/global/modules", moduleName);
         return this.getTemplate(modulePath);
       }
       /**
@@ -13422,14 +13626,14 @@ var init_prompt_builder = __esm({
         if (this._checklistsCache && now - this._checklistsCacheTime < this.TEMPLATE_CACHE_TTL_MS) {
           return this._checklistsCache;
         }
-        const checklistsDir = path26.join(__dirname, "..", "..", "templates", "checklists");
+        const checklistsDir = path27.join(__dirname, "..", "..", "templates", "checklists");
         const checklists = {};
         try {
-          if (fs26.existsSync(checklistsDir)) {
-            const files = fs26.readdirSync(checklistsDir).filter((f) => f.endsWith(".md"));
+          if (fs27.existsSync(checklistsDir)) {
+            const files = fs27.readdirSync(checklistsDir).filter((f) => f.endsWith(".md"));
             for (const file of files) {
               const name = file.replace(".md", "");
-              const templatePath = path26.join(checklistsDir, file);
+              const templatePath = path27.join(checklistsDir, file);
               const content = this.getTemplate(templatePath);
               if (content) {
                 checklists[name] = content;
@@ -13548,7 +13752,7 @@ var init_prompt_builder = __esm({
         if (this._checklistRoutingCache && now - this._checklistRoutingCacheTime < this.TEMPLATE_CACHE_TTL_MS) {
           return this._checklistRoutingCache;
         }
-        const routingPath = path26.join(
+        const routingPath = path27.join(
           __dirname,
           "..",
           "..",
@@ -13947,8 +14151,8 @@ Context: ${fileCount} files available. Read what you need.
 });
 
 // core/agentic/template-executor.ts
-import fs27 from "node:fs/promises";
-import path27 from "node:path";
+import fs28 from "node:fs/promises";
+import path28 from "node:path";
 var ORCHESTRATED_COMMANDS, SIMPLE_COMMANDS, TemplateExecutor, templateExecutor, template_executor_default;
 var init_template_executor = __esm({
   "core/agentic/template-executor.ts"() {
@@ -13966,7 +14170,7 @@ var init_template_executor = __esm({
        * Get npm root for templates path
        */
       async getNpmRoot() {
-        const moduleDir = path27.dirname(__require.resolve("prjct-cli/package.json"));
+        const moduleDir = path28.dirname(__require.resolve("prjct-cli/package.json"));
         return moduleDir;
       }
       /**
@@ -13987,9 +14191,9 @@ var init_template_executor = __esm({
         let templatesDir;
         try {
           const npmRoot = await this.getNpmRoot();
-          templatesDir = path27.join(npmRoot, "templates");
+          templatesDir = path28.join(npmRoot, "templates");
         } catch {
-          templatesDir = path27.join(__dirname, "..", "..", "templates");
+          templatesDir = path28.join(__dirname, "..", "..", "templates");
         }
         return {
           projectPath,
@@ -14000,14 +14204,14 @@ var init_template_executor = __esm({
           agentName: activeProvider.displayName,
           agentSettingsPath: path_manager_default.getAgentSettingsPath(),
           paths: {
-            orchestrator: path27.join(templatesDir, "agentic", "orchestrator.md"),
-            agentRouting: path27.join(templatesDir, "agentic", "agent-routing.md"),
-            taskFragmentation: path27.join(templatesDir, "agentic", "task-fragmentation.md"),
-            commandTemplate: path27.join(templatesDir, "commands", `${command}.md`),
-            repoAnalysis: path27.join(globalPath, "analysis", "repo-analysis.json"),
-            agentsDir: path27.join(globalPath, "agents"),
+            orchestrator: path28.join(templatesDir, "agentic", "orchestrator.md"),
+            agentRouting: path28.join(templatesDir, "agentic", "agent-routing.md"),
+            taskFragmentation: path28.join(templatesDir, "agentic", "task-fragmentation.md"),
+            commandTemplate: path28.join(templatesDir, "commands", `${command}.md`),
+            repoAnalysis: path28.join(globalPath, "analysis", "repo-analysis.json"),
+            agentsDir: path28.join(globalPath, "agents"),
             skillsDir: activeProvider.skillsDir,
-            stateJson: path27.join(globalPath, "storage", "state.json")
+            stateJson: path28.join(globalPath, "storage", "state.json")
           }
         };
       }
@@ -14025,8 +14229,8 @@ var init_template_executor = __esm({
       async hasAgents(projectPath) {
         try {
           const projectId = await this.getProjectId(projectPath);
-          const agentsDir = path27.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
-          const files = await fs27.readdir(agentsDir);
+          const agentsDir = path28.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
+          const files = await fs28.readdir(agentsDir);
           return files.some((f) => f.endsWith(".md"));
         } catch (error) {
           if (isNotFoundError(error)) return false;
@@ -14039,8 +14243,8 @@ var init_template_executor = __esm({
       async getAvailableAgents(projectPath) {
         try {
           const projectId = await this.getProjectId(projectPath);
-          const agentsDir = path27.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
-          const files = await fs27.readdir(agentsDir);
+          const agentsDir = path28.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
+          const files = await fs28.readdir(agentsDir);
           return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
         } catch {
           return [];
@@ -14149,7 +14353,7 @@ When fragmenting tasks:
 
 // core/agentic/tool-registry.ts
 import { exec as exec6 } from "node:child_process";
-import fs28 from "node:fs/promises";
+import fs29 from "node:fs/promises";
 import { promisify as promisify6 } from "node:util";
 var execAsync2, toolRegistry, tool_registry_default;
 var init_tool_registry = __esm({
@@ -14193,14 +14397,14 @@ var init_tool_registry = __esm({
     };
     toolRegistry.register("Read", async (filePath) => {
       try {
-        return await fs28.readFile(filePath, "utf-8");
+        return await fs29.readFile(filePath, "utf-8");
       } catch (_error) {
         return null;
       }
     });
     toolRegistry.register("Write", async (filePath, content) => {
       try {
-        await fs28.writeFile(filePath, content, "utf-8");
+        await fs29.writeFile(filePath, content, "utf-8");
         return true;
       } catch (_error) {
         return false;
@@ -14235,23 +14439,23 @@ var init_tool_registry = __esm({
 });
 
 // core/agentic/command-executor.ts
-import fs29 from "node:fs";
+import fs30 from "node:fs";
 import os9 from "node:os";
-import path28 from "node:path";
+import path29 from "node:path";
 function signalStart(commandName) {
   try {
-    const dir = path28.dirname(RUNNING_FILE);
-    if (!fs29.existsSync(dir)) {
-      fs29.mkdirSync(dir, { recursive: true });
+    const dir = path29.dirname(RUNNING_FILE);
+    if (!fs30.existsSync(dir)) {
+      fs30.mkdirSync(dir, { recursive: true });
     }
-    fs29.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
+    fs30.writeFileSync(RUNNING_FILE, `/p:${commandName}`);
   } catch (_error) {
   }
 }
 function signalEnd() {
   try {
-    if (fs29.existsSync(RUNNING_FILE)) {
-      fs29.unlinkSync(RUNNING_FILE);
+    if (fs30.existsSync(RUNNING_FILE)) {
+      fs30.unlinkSync(RUNNING_FILE);
     }
   } catch (_error) {
   }
@@ -14273,7 +14477,7 @@ var init_command_executor = __esm({
     init_template_executor();
     init_template_loader();
     init_tool_registry();
-    RUNNING_FILE = path28.join(os9.homedir(), ".prjct-cli", ".running");
+    RUNNING_FILE = path29.join(os9.homedir(), ".prjct-cli", ".running");
     __name(signalStart, "signalStart");
     __name(signalEnd, "signalEnd");
     CommandExecutor = class {
@@ -14582,10 +14786,10 @@ var init_command_executor = __esm({
 });
 
 // core/infrastructure/update-checker.ts
-import fs30 from "node:fs";
+import fs31 from "node:fs";
 import https from "node:https";
 import os10 from "node:os";
-import path29 from "node:path";
+import path30 from "node:path";
 import chalk8 from "chalk";
 var UpdateChecker, update_checker_default;
 var init_update_checker = __esm({
@@ -14601,8 +14805,8 @@ var init_update_checker = __esm({
       checkInterval;
       constructor() {
         this.packageName = "prjct-cli";
-        this.cacheDir = path29.join(os10.homedir(), ".prjct-cli", "config");
-        this.cacheFile = path29.join(this.cacheDir, "update-cache.json");
+        this.cacheDir = path30.join(os10.homedir(), ".prjct-cli", "config");
+        this.cacheFile = path30.join(this.cacheDir, "update-cache.json");
         this.checkInterval = 24 * 60 * 60 * 1e3;
       }
       /**
@@ -14610,8 +14814,8 @@ var init_update_checker = __esm({
        */
       getCurrentVersion() {
         try {
-          const packageJsonPath = path29.join(__dirname, "..", "..", "package.json");
-          const packageJson = JSON.parse(fs30.readFileSync(packageJsonPath, "utf8"));
+          const packageJsonPath = path30.join(__dirname, "..", "..", "package.json");
+          const packageJson = JSON.parse(fs31.readFileSync(packageJsonPath, "utf8"));
           return packageJson.version;
         } catch (error) {
           console.error("Error reading package version:", error.message);
@@ -14680,8 +14884,8 @@ var init_update_checker = __esm({
        */
       readCache() {
         try {
-          if (fs30.existsSync(this.cacheFile)) {
-            const cache2 = JSON.parse(fs30.readFileSync(this.cacheFile, "utf8"));
+          if (fs31.existsSync(this.cacheFile)) {
+            const cache2 = JSON.parse(fs31.readFileSync(this.cacheFile, "utf8"));
             return cache2;
           }
         } catch (_error) {
@@ -14693,10 +14897,10 @@ var init_update_checker = __esm({
        */
       writeCache(data) {
         try {
-          if (!fs30.existsSync(this.cacheDir)) {
-            fs30.mkdirSync(this.cacheDir, { recursive: true });
+          if (!fs31.existsSync(this.cacheDir)) {
+            fs31.mkdirSync(this.cacheDir, { recursive: true });
           }
-          fs30.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
+          fs31.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
         } catch (_error) {
         }
       }
@@ -14854,8 +15058,8 @@ var init_agent_generator = __esm({
 });
 
 // core/agentic/agent-router.ts
-import fs31 from "node:fs/promises";
-import path30 from "node:path";
+import fs32 from "node:fs/promises";
+import path31 from "node:path";
 var AgentRouter, agent_router_default;
 var init_agent_router = __esm({
   "core/agentic/agent-router.ts"() {
@@ -14884,12 +15088,12 @@ var init_agent_router = __esm({
       async loadAvailableAgents() {
         if (!this.agentsPath) return [];
         try {
-          const files = await fs31.readdir(this.agentsPath);
+          const files = await fs32.readdir(this.agentsPath);
           const agents = [];
           for (const file of files) {
             if (file.endsWith(".md")) {
               const name = file.replace(".md", "");
-              const content = await fs31.readFile(path30.join(this.agentsPath, file), "utf-8");
+              const content = await fs32.readFile(path31.join(this.agentsPath, file), "utf-8");
               agents.push({ name, content });
             }
           }
@@ -14914,8 +15118,8 @@ var init_agent_router = __esm({
       async loadAgent(name) {
         if (!this.agentsPath) return null;
         try {
-          const filePath = path30.join(this.agentsPath, `${name}.md`);
-          const content = await fs31.readFile(filePath, "utf-8");
+          const filePath = path31.join(this.agentsPath, `${name}.md`);
+          const content = await fs32.readFile(filePath, "utf-8");
           return { name, content };
         } catch (error) {
           if (!isNotFoundError(error)) {
@@ -14943,7 +15147,7 @@ var init_agent_router = __esm({
        */
       async logUsage(task, agent, _projectPath) {
         try {
-          const logPath = path30.join(
+          const logPath = path31.join(
             process.env.HOME || "",
             ".prjct-cli",
             "projects",
@@ -14957,7 +15161,7 @@ var init_agent_router = __esm({
             projectId: this.projectId
           })}
 `;
-          await fs31.appendFile(logPath, entry);
+          await fs32.appendFile(logPath, entry);
         } catch (error) {
           if (!isNotFoundError(error)) {
             console.error(`Agent usage log error: ${error.message}`);
@@ -14970,15 +15174,15 @@ var init_agent_router = __esm({
 });
 
 // core/infrastructure/agent-detector.ts
-import fs32 from "node:fs";
-import path31 from "node:path";
+import fs33 from "node:fs";
+import path32 from "node:path";
 function isClaudeEnvironment() {
   if (process.env.CLAUDE_AGENT || process.env.ANTHROPIC_CLAUDE) return true;
   if (global.mcp || process.env.MCP_AVAILABLE) return true;
   const projectRoot = process.cwd();
-  if (fs32.existsSync(path31.join(projectRoot, "CLAUDE.md"))) return true;
+  if (fs33.existsSync(path32.join(projectRoot, "CLAUDE.md"))) return true;
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  if (fs32.existsSync(path31.join(homeDir, ".claude"))) return true;
+  if (fs33.existsSync(path32.join(homeDir, ".claude"))) return true;
   const cwd = process.cwd();
   if (cwd.includes("/.claude/") || cwd.includes("/claude-workspace/")) return true;
   return false;
@@ -15626,7 +15830,7 @@ var init_context_selector = __esm({
 });
 
 // core/services/file-categorizer.ts
-import path32 from "node:path";
+import path33 from "node:path";
 var HEURISTIC_PATTERNS, FileCategorizer, fileCategorizer;
 var init_file_categorizer = __esm({
   "core/services/file-categorizer.ts"() {
@@ -15722,8 +15926,8 @@ var init_file_categorizer = __esm({
               if (!domainPatterns.has(domain)) {
                 domainPatterns.set(domain, /* @__PURE__ */ new Set());
               }
-              const dir = path32.dirname(file.path);
-              domainPatterns.get(domain).add(`**/${path32.basename(dir)}/**`);
+              const dir = path33.dirname(file.path);
+              domainPatterns.get(domain).add(`**/${path33.basename(dir)}/**`);
             }
           }
         }
@@ -15908,7 +16112,7 @@ var init_file_categorizer = __esm({
 });
 
 // core/services/file-scorer.ts
-import path33 from "node:path";
+import path34 from "node:path";
 var RELEVANCE_THRESHOLD, CONFIG_PATTERNS, IMPORTANT_NAME_PATTERNS, FileScorer, fileScorer;
 var init_file_scorer = __esm({
   "core/services/file-scorer.ts"() {
@@ -16043,7 +16247,7 @@ var init_file_scorer = __esm({
        * Config files are always important
        */
       calculateConfigRelevance(stats) {
-        const filename = path33.basename(stats.path);
+        const filename = path34.basename(stats.path);
         for (const pattern of CONFIG_PATTERNS) {
           if (pattern.test(filename) || pattern.test(stats.path)) {
             return 20;
@@ -16056,13 +16260,13 @@ var init_file_scorer = __esm({
        * Certain filenames indicate importance
        */
       calculateNameRelevance(stats) {
-        const filename = path33.basename(stats.path);
+        const filename = path34.basename(stats.path);
         for (const pattern of IMPORTANT_NAME_PATTERNS) {
           if (pattern.test(filename)) {
             return 15;
           }
         }
-        const dir = path33.dirname(stats.path);
+        const dir = path34.dirname(stats.path);
         if (dir.includes("/api/") || dir.includes("/routes/")) return 10;
         if (dir.includes("/components/") && filename.startsWith("index")) return 10;
         if (dir.includes("/pages/") || dir.includes("/app/")) return 8;
@@ -16463,8 +16667,8 @@ var init_memory_service = __esm({
 });
 
 // core/services/nested-context-resolver.ts
-import fs33 from "node:fs/promises";
-import path34 from "node:path";
+import fs34 from "node:fs/promises";
+import path35 from "node:path";
 var NestedContextResolver;
 var init_nested_context_resolver = __esm({
   "core/services/nested-context-resolver.ts"() {
@@ -16478,7 +16682,7 @@ var init_nested_context_resolver = __esm({
       rootPath;
       monoInfo = null;
       constructor(rootPath) {
-        this.rootPath = path34.resolve(rootPath);
+        this.rootPath = path35.resolve(rootPath);
       }
       /**
        * Initialize the resolver with monorepo detection
@@ -16491,14 +16695,14 @@ var init_nested_context_resolver = __esm({
        */
       async discoverContextFiles() {
         const contexts = [];
-        const rootPrjctPath = path34.join(this.rootPath, "PRJCT.md");
+        const rootPrjctPath = path35.join(this.rootPath, "PRJCT.md");
         if (await fileExists(rootPrjctPath)) {
           const rootContext = await this.loadContext(rootPrjctPath, null);
           contexts.push(rootContext);
         }
         if (this.monoInfo?.isMonorepo) {
           for (const pkg of this.monoInfo.packages) {
-            const pkgPrjctPath = path34.join(pkg.path, "PRJCT.md");
+            const pkgPrjctPath = path35.join(pkg.path, "PRJCT.md");
             if (await fileExists(pkgPrjctPath)) {
               const parentContext = contexts.find((c) => c.depth === 0) || null;
               const pkgContext = await this.loadContext(pkgPrjctPath, parentContext, pkg);
@@ -16517,9 +16721,9 @@ var init_nested_context_resolver = __esm({
        * Load a single PRJCT.md file into a NestedContext
        */
       async loadContext(filePath, parent, pkg = null) {
-        const content = await fs33.readFile(filePath, "utf-8");
-        const relativePath = path34.relative(this.rootPath, filePath);
-        const depth = relativePath.split(path34.sep).length - 1;
+        const content = await fs34.readFile(filePath, "utf-8");
+        const relativePath = path35.relative(this.rootPath, filePath);
+        const depth = relativePath.split(path35.sep).length - 1;
         return {
           path: filePath,
           relativePath,
@@ -16573,14 +16777,14 @@ var init_nested_context_resolver = __esm({
         const scan = /* @__PURE__ */ __name(async (currentDir, depth) => {
           if (depth > 5) return;
           try {
-            const entries = await fs33.readdir(currentDir, { withFileTypes: true });
+            const entries = await fs34.readdir(currentDir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
                 continue;
               }
               if (entry.isDirectory()) {
-                const subDir = path34.join(currentDir, entry.name);
-                const prjctPath = path34.join(subDir, "PRJCT.md");
+                const subDir = path35.join(currentDir, entry.name);
+                const prjctPath = path35.join(subDir, "PRJCT.md");
                 if (await fileExists(prjctPath) && !existingPaths.has(prjctPath)) {
                   const parent = this.findParentContext(prjctPath, existing.concat(found));
                   const context2 = await this.loadContext(prjctPath, parent);
@@ -16603,10 +16807,10 @@ var init_nested_context_resolver = __esm({
        * Find the parent context for a given path
        */
       findParentContext(filePath, contexts) {
-        const fileDir = path34.dirname(filePath);
+        const fileDir = path35.dirname(filePath);
         const sorted = [...contexts].sort((a, b) => b.depth - a.depth);
         for (const ctx of sorted) {
-          const ctxDir = path34.dirname(ctx.path);
+          const ctxDir = path35.dirname(ctx.path);
           if (fileDir.startsWith(ctxDir) && fileDir !== ctxDir) {
             return ctx;
           }
@@ -16619,10 +16823,10 @@ var init_nested_context_resolver = __esm({
        */
       async resolveContextForPath(targetPath) {
         const contexts = await this.discoverContextFiles();
-        const targetDir = path34.resolve(targetPath);
+        const targetDir = path35.resolve(targetPath);
         let bestMatch = null;
         for (const ctx of contexts) {
-          const ctxDir = path34.dirname(ctx.path);
+          const ctxDir = path35.dirname(ctx.path);
           if (targetDir.startsWith(ctxDir)) {
             if (!bestMatch || ctx.depth > bestMatch.depth) {
               bestMatch = ctx;
@@ -16714,14 +16918,14 @@ ${content}`);
        */
       async discoverAgentFiles() {
         const agentFiles = [];
-        const rootAgentsPath = path34.join(this.rootPath, "AGENTS.md");
+        const rootAgentsPath = path35.join(this.rootPath, "AGENTS.md");
         if (await fileExists(rootAgentsPath)) {
           const rootAgents = await this.loadAgents(rootAgentsPath, null);
           agentFiles.push(rootAgents);
         }
         if (this.monoInfo?.isMonorepo) {
           for (const pkg of this.monoInfo.packages) {
-            const pkgAgentsPath = path34.join(pkg.path, "AGENTS.md");
+            const pkgAgentsPath = path35.join(pkg.path, "AGENTS.md");
             if (await fileExists(pkgAgentsPath)) {
               const parentAgents = agentFiles.find((a) => a.depth === 0) || null;
               const pkgAgents = await this.loadAgents(pkgAgentsPath, parentAgents, pkg);
@@ -16740,9 +16944,9 @@ ${content}`);
        * Load a single AGENTS.md file into a NestedAgents structure
        */
       async loadAgents(filePath, parent, pkg = null) {
-        const content = await fs33.readFile(filePath, "utf-8");
-        const relativePath = path34.relative(this.rootPath, filePath);
-        const depth = relativePath.split(path34.sep).length - 1;
+        const content = await fs34.readFile(filePath, "utf-8");
+        const relativePath = path35.relative(this.rootPath, filePath);
+        const depth = relativePath.split(path35.sep).length - 1;
         return {
           path: filePath,
           relativePath,
@@ -16875,14 +17079,14 @@ ${content}`);
         const scan = /* @__PURE__ */ __name(async (currentDir, depth) => {
           if (depth > 5) return;
           try {
-            const entries = await fs33.readdir(currentDir, { withFileTypes: true });
+            const entries = await fs34.readdir(currentDir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
                 continue;
               }
               if (entry.isDirectory()) {
-                const subDir = path34.join(currentDir, entry.name);
-                const agentsPath = path34.join(subDir, "AGENTS.md");
+                const subDir = path35.join(currentDir, entry.name);
+                const agentsPath = path35.join(subDir, "AGENTS.md");
                 if (await fileExists(agentsPath) && !existingPaths.has(agentsPath)) {
                   const parent = this.findParentAgents(agentsPath, existing.concat(found));
                   const agents = await this.loadAgents(agentsPath, parent);
@@ -16905,10 +17109,10 @@ ${content}`);
        * Find the parent agents file for a given path
        */
       findParentAgents(filePath, agentFiles) {
-        const fileDir = path34.dirname(filePath);
+        const fileDir = path35.dirname(filePath);
         const sorted = [...agentFiles].sort((a, b) => b.depth - a.depth);
         for (const agents of sorted) {
-          const agentsDir = path34.dirname(agents.path);
+          const agentsDir = path35.dirname(agents.path);
           if (fileDir.startsWith(agentsDir) && fileDir !== agentsDir) {
             return agents;
           }
@@ -16921,10 +17125,10 @@ ${content}`);
        */
       async resolveAgentsForPath(targetPath) {
         const agentFiles = await this.discoverAgentFiles();
-        const targetDir = path34.resolve(targetPath);
+        const targetDir = path35.resolve(targetPath);
         let bestMatch = null;
         for (const agents of agentFiles) {
-          const agentsDir = path34.dirname(agents.path);
+          const agentsDir = path35.dirname(agents.path);
           if (targetDir.startsWith(agentsDir)) {
             if (!bestMatch || agents.depth > bestMatch.depth) {
               bestMatch = agents;
@@ -17508,16 +17712,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs51 = await import("node:fs/promises");
-        const path60 = await import("node:path");
+        const fs52 = await import("node:fs/promises");
+        const path61 = await import("node:path");
         try {
-          const files = await fs51.readdir(this.projectPath);
+          const files = await fs52.readdir(this.projectPath);
           if (files.includes("turbo.json") || files.includes("lerna.json") || files.includes("nx.json")) {
             return "monorepo";
           }
           if (files.includes("package.json")) {
-            const pkgPath = path60.join(this.projectPath, "package.json");
-            const pkgContent = await fs51.readFile(pkgPath, "utf-8");
+            const pkgPath = path61.join(this.projectPath, "package.json");
+            const pkgContent = await fs52.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -17553,32 +17757,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs51 = await import("node:fs/promises");
-        const path60 = await import("node:path");
+        const fs52 = await import("node:fs/promises");
+        const path61 = await import("node:path");
         const os17 = await import("node:os");
         const agents = [];
         try {
-          await fs51.access(path60.join(os17.homedir(), ".claude"));
+          await fs52.access(path61.join(os17.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs51.access(path60.join(this.projectPath, ".cursorrules"));
+          await fs52.access(path61.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs51.access(path60.join(this.projectPath, ".windsurfrules"));
+          await fs52.access(path61.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs51.access(path60.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs52.access(path61.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs51.access(path60.join(os17.homedir(), ".gemini"));
+          await fs52.access(path61.join(os17.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -17588,17 +17792,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs51 = await import("node:fs/promises");
-        const path60 = await import("node:path");
+        const fs52 = await import("node:fs/promises");
+        const path61 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs51.readdir(this.projectPath);
+          const files = await fs52.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path60.join(this.projectPath, "package.json");
-            const pkgContent = await fs51.readFile(pkgPath, "utf-8");
+            const pkgPath = path61.join(this.projectPath, "package.json");
+            const pkgContent = await fs52.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -17705,14 +17909,14 @@ var init_wizard = __esm({
 
 // core/context/generator.ts
 import { exec as exec9 } from "node:child_process";
-import fs34 from "node:fs/promises";
-import path35 from "node:path";
+import fs35 from "node:fs/promises";
+import path36 from "node:path";
 import { promisify as promisify9 } from "node:util";
 async function generateContext(projectId, repoPath) {
   const _globalPath = path_manager_default.getGlobalProjectPath(projectId);
   const contextPath = path_manager_default.getContextPath(projectId);
   const storage = getStorage(projectId);
-  await fs34.mkdir(contextPath, { recursive: true });
+  await fs35.mkdir(contextPath, { recursive: true });
   const project = await storage.read(["project"]) || {};
   const taskPaths = await storage.list(["task"]);
   const featurePaths = await storage.list(["feature"]);
@@ -17794,8 +17998,8 @@ async function getPackageData(repoPath) {
     scripts: {}
   };
   try {
-    const pkgPath = path35.join(repoPath, "package.json");
-    const pkg = JSON.parse(await fs34.readFile(pkgPath, "utf-8"));
+    const pkgPath = path36.join(repoPath, "package.json");
+    const pkg = JSON.parse(await fs35.readFile(pkgPath, "utf-8"));
     data.dependencies = pkg.dependencies || {};
     data.devDependencies = pkg.devDependencies || {};
     data.scripts = pkg.scripts || {};
@@ -17804,7 +18008,7 @@ async function getPackageData(repoPath) {
   return data;
 }
 async function generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath) {
-  const projectName = project.name || path35.basename(repoPath);
+  const projectName = project.name || path36.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");
@@ -17879,7 +18083,7 @@ ${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || "Specialis
     \u2514\u2500\u2500 pending.json
 \`\`\`
 `;
-  await fs34.writeFile(path35.join(contextPath, "CLAUDE.md"), content, "utf-8");
+  await fs35.writeFile(path36.join(contextPath, "CLAUDE.md"), content, "utf-8");
 }
 async function generateNowMd(contextPath, tasks) {
   const currentTask = tasks.find((t) => t.status === "in_progress");
@@ -17894,7 +18098,7 @@ async function generateNowMd(contextPath, tasks) {
 
 _No active task. Use /p:now to start._
 `;
-  await fs34.writeFile(path35.join(contextPath, "now.md"), content, "utf-8");
+  await fs35.writeFile(path36.join(contextPath, "now.md"), content, "utf-8");
 }
 async function generateQueueMd(contextPath, tasks) {
   const pendingTasks = tasks.filter((t) => t.status === "pending");
@@ -17902,7 +18106,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 fs34.writeFile(path35.join(contextPath, "queue.md"), content, "utf-8");
+  await fs35.writeFile(path36.join(contextPath, "queue.md"), content, "utf-8");
 }
 async function generateSummaryMd(contextPath, project, gitData, pkgData) {
   const content = `# PROJECT SUMMARY
@@ -17922,7 +18126,7 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 - Production: ${Object.keys(pkgData.dependencies).length}
 - Dev: ${Object.keys(pkgData.devDependencies).length}
 `;
-  await fs34.writeFile(path35.join(contextPath, "summary.md"), content, "utf-8");
+  await fs35.writeFile(path36.join(contextPath, "summary.md"), content, "utf-8");
 }
 var execAsync5;
 var init_generator = __esm({
@@ -17943,8 +18147,8 @@ var init_generator = __esm({
 
 // core/domain/analyzer.ts
 import { exec as execCallback5 } from "node:child_process";
-import fs35 from "node:fs/promises";
-import path36 from "node:path";
+import fs36 from "node:fs/promises";
+import path37 from "node:path";
 import { promisify as promisify10 } from "node:util";
 var exec10, CodebaseAnalyzer, analyzer, analyzer_default2;
 var init_analyzer2 = __esm({
@@ -17968,8 +18172,8 @@ var init_analyzer2 = __esm({
        */
       async readPackageJson() {
         try {
-          const packagePath = path36.join(this.projectPath, "package.json");
-          const content = await fs35.readFile(packagePath, "utf-8");
+          const packagePath = path37.join(this.projectPath, "package.json");
+          const content = await fs36.readFile(packagePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -17983,8 +18187,8 @@ var init_analyzer2 = __esm({
        */
       async readCargoToml() {
         try {
-          const cargoPath = path36.join(this.projectPath, "Cargo.toml");
-          return await fs35.readFile(cargoPath, "utf-8");
+          const cargoPath = path37.join(this.projectPath, "Cargo.toml");
+          return await fs36.readFile(cargoPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -17997,8 +18201,8 @@ var init_analyzer2 = __esm({
        */
       async readRequirements() {
         try {
-          const reqPath = path36.join(this.projectPath, "requirements.txt");
-          return await fs35.readFile(reqPath, "utf-8");
+          const reqPath = path37.join(this.projectPath, "requirements.txt");
+          return await fs36.readFile(reqPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18011,8 +18215,8 @@ var init_analyzer2 = __esm({
        */
       async readGoMod() {
         try {
-          const goModPath = path36.join(this.projectPath, "go.mod");
-          return await fs35.readFile(goModPath, "utf-8");
+          const goModPath = path37.join(this.projectPath, "go.mod");
+          return await fs36.readFile(goModPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18025,8 +18229,8 @@ var init_analyzer2 = __esm({
        */
       async readGemfile() {
         try {
-          const gemfilePath = path36.join(this.projectPath, "Gemfile");
-          return await fs35.readFile(gemfilePath, "utf-8");
+          const gemfilePath = path37.join(this.projectPath, "Gemfile");
+          return await fs36.readFile(gemfilePath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18039,8 +18243,8 @@ var init_analyzer2 = __esm({
        */
       async readMixExs() {
         try {
-          const mixPath = path36.join(this.projectPath, "mix.exs");
-          return await fs35.readFile(mixPath, "utf-8");
+          const mixPath = path37.join(this.projectPath, "mix.exs");
+          return await fs36.readFile(mixPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18053,8 +18257,8 @@ var init_analyzer2 = __esm({
        */
       async readPomXml() {
         try {
-          const pomPath = path36.join(this.projectPath, "pom.xml");
-          return await fs35.readFile(pomPath, "utf-8");
+          const pomPath = path37.join(this.projectPath, "pom.xml");
+          return await fs36.readFile(pomPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18067,8 +18271,8 @@ var init_analyzer2 = __esm({
        */
       async readComposerJson() {
         try {
-          const composerPath = path36.join(this.projectPath, "composer.json");
-          const content = await fs35.readFile(composerPath, "utf-8");
+          const composerPath = path37.join(this.projectPath, "composer.json");
+          const content = await fs36.readFile(composerPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -18082,8 +18286,8 @@ var init_analyzer2 = __esm({
        */
       async readPyprojectToml() {
         try {
-          const pyprojectPath = path36.join(this.projectPath, "pyproject.toml");
-          return await fs35.readFile(pyprojectPath, "utf-8");
+          const pyprojectPath = path37.join(this.projectPath, "pyproject.toml");
+          return await fs36.readFile(pyprojectPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18119,7 +18323,7 @@ var init_analyzer2 = __esm({
        */
       async listConfigFiles() {
         try {
-          const entries = await fs35.readdir(this.projectPath);
+          const entries = await fs36.readdir(this.projectPath);
           const configPatterns = [
             /^package\.json$/,
             /^Cargo\.toml$/,
@@ -18149,7 +18353,7 @@ var init_analyzer2 = __esm({
        */
       async listDirectories() {
         try {
-          const entries = await fs35.readdir(this.projectPath, { withFileTypes: true });
+          const entries = await fs36.readdir(this.projectPath, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -18220,7 +18424,7 @@ var init_analyzer2 = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs35.access(path36.join(this.projectPath, filename));
+          await fs36.access(path37.join(this.projectPath, filename));
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -18234,8 +18438,8 @@ var init_analyzer2 = __esm({
        */
       async readFile(relativePath) {
         try {
-          const fullPath = path36.join(this.projectPath, relativePath);
-          return await fs35.readFile(fullPath, "utf-8");
+          const fullPath = path37.join(this.projectPath, relativePath);
+          return await fs36.readFile(fullPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18483,8 +18687,8 @@ var analysis_exports = {};
 __export(analysis_exports, {
   AnalysisCommands: () => AnalysisCommands
 });
-import fs36 from "node:fs/promises";
-import path37 from "node:path";
+import fs37 from "node:fs/promises";
+import path38 from "node:path";
 import prompts2 from "prompts";
 var AnalysisCommands;
 var init_analysis2 = __esm({
@@ -18571,7 +18775,7 @@ var init_analysis2 = __esm({
         lines.push("# Repository Analysis\n");
         lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
 `);
-        const projectName = path37.basename(projectPath);
+        const projectName = path38.basename(projectPath);
         lines.push(`## Project: ${projectName}
 `);
         lines.push("## Stack Detected\n");
@@ -18711,10 +18915,10 @@ var init_analysis2 = __esm({
             }
             return { success: result2.success };
           }
-          const claudeMdPath = path37.join(globalPath, "context", "CLAUDE.md");
+          const claudeMdPath = path38.join(globalPath, "context", "CLAUDE.md");
           let existingContent = null;
           try {
-            existingContent = await fs36.readFile(claudeMdPath, "utf-8");
+            existingContent = await fs37.readFile(claudeMdPath, "utf-8");
           } catch {
           }
           const isNonInteractive = !process.stdin.isTTY || options.json;
@@ -18733,7 +18937,7 @@ var init_analysis2 = __esm({
             }
             let newContent;
             try {
-              newContent = await fs36.readFile(claudeMdPath, "utf-8");
+              newContent = await fs37.readFile(claudeMdPath, "utf-8");
             } catch {
               newContent = "";
             }
@@ -18944,7 +19148,7 @@ ${formatFullDiff(diff)}`);
           let projectName = "Unknown";
           try {
             const projectJson = JSON.parse(
-              await fs36.readFile(path37.join(globalPath, "project.json"), "utf-8")
+              await fs37.readFile(path38.join(globalPath, "project.json"), "utf-8")
             );
             projectName = projectJson.name || "Unknown";
           } catch {
@@ -19063,19 +19267,23 @@ ${formatFullDiff(diff)}`);
           }
           const checker = createStalenessChecker(projectPath);
           const status = await checker.check(projectId);
+          const sessionInfo = await checker.getSessionInfo(projectId);
           if (options.json) {
             console.log(
               JSON.stringify({
                 success: true,
-                ...status
+                ...status,
+                session: sessionInfo
               })
             );
-            return { success: true, data: status };
+            return { success: true, data: { ...status, session: sessionInfo } };
           }
           console.log("");
           console.log(checker.formatStatus(status));
           console.log("");
-          return { success: true, data: status };
+          console.log(checker.formatSessionInfo(sessionInfo));
+          console.log("");
+          return { success: true, data: { ...status, session: sessionInfo } };
         } catch (error) {
           const errMsg = error.message;
           if (options.json) {
@@ -19241,7 +19449,7 @@ var planning_exports = {};
 __export(planning_exports, {
   PlanningCommands: () => PlanningCommands
 });
-import path38 from "node:path";
+import path39 from "node:path";
 async function getAnalysisCommands() {
   if (!_analysisCommands) {
     const { AnalysisCommands: AnalysisCommands2 } = await Promise.resolve().then(() => (init_analysis2(), analysis_exports));
@@ -19348,7 +19556,7 @@ var init_planning = __esm({
             );
           }
           for (const [filePath, content] of Object.entries(baseFiles)) {
-            await tool_registry_default.get("Write")(path38.join(globalPath, filePath), content);
+            await tool_registry_default.get("Write")(path39.join(globalPath, filePath), content);
           }
           const isEmpty = await this._detectEmptyDirectory(projectPath);
           const hasCode = await this._detectExistingCode(projectPath);
@@ -19375,7 +19583,7 @@ var init_planning = __esm({
               return { success: true, mode: "blank_no_idea", projectId, wizard: wizardResult };
             }
             output_default.spin("architect mode...");
-            const sessionPath = path38.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path39.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -19561,7 +19769,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 = path38.join(globalPath, "planning", "architect-session.md");
+          const planPath = path39.join(globalPath, "planning", "architect-session.md");
           let planContent;
           try {
             planContent = await file_helper_exports.readFile(planPath);
@@ -19636,7 +19844,7 @@ ${"=".repeat(60)}`);
           if (isComplex) {
             output_default.spin("analyzing idea...");
             const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-            const sessionPath = path38.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path39.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -19692,10 +19900,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!featureName) {
             output_default.spin("loading specs...");
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
-            const specsPath2 = path38.join(globalPath2, "planning", "specs");
+            const specsPath2 = path39.join(globalPath2, "planning", "specs");
             try {
-              const fs51 = await import("node:fs/promises");
-              const files = await fs51.readdir(specsPath2);
+              const fs52 = await import("node:fs/promises");
+              const files = await fs52.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -19718,10 +19926,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           }
           output_default.spin("creating spec...");
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-          const specsPath = path38.join(globalPath, "planning", "specs");
+          const specsPath = path39.join(globalPath, "planning", "specs");
           await file_helper_exports.ensureDir(specsPath);
           const slug = featureName.toLowerCase().replace(/\s+/g, "-");
-          const specFile = path38.join(specsPath, `${slug}.md`);
+          const specFile = path39.join(specsPath, `${slug}.md`);
           const specContent = `# Specification: ${featureName}
 
 ## Overview
@@ -19909,14 +20117,15 @@ var init_project_service = __esm({
 
 // core/services/staleness-checker.ts
 import { exec as exec11 } from "node:child_process";
-import fs37 from "node:fs/promises";
-import path39 from "node:path";
+import fs38 from "node:fs/promises";
+import path40 from "node:path";
 import { promisify as promisify11 } from "node:util";
 var execAsync6, DEFAULT_CONFIG, StalenessChecker, createStalenessChecker;
 var init_staleness_checker = __esm({
   "core/services/staleness-checker.ts"() {
     "use strict";
     init_path_manager();
+    init_session_tracker();
     execAsync6 = promisify11(exec11);
     DEFAULT_CONFIG = {
       commitThreshold: 10,
@@ -19958,10 +20167,10 @@ var init_staleness_checker = __esm({
           significantChanges: []
         };
         try {
-          const projectJsonPath = path39.join(path_manager_default.getGlobalProjectPath(projectId), "project.json");
+          const projectJsonPath = path40.join(path_manager_default.getGlobalProjectPath(projectId), "project.json");
           let projectJson = {};
           try {
-            projectJson = JSON.parse(await fs37.readFile(projectJsonPath, "utf-8"));
+            projectJson = JSON.parse(await fs38.readFile(projectJsonPath, "utf-8"));
           } catch {
             status.isStale = true;
             status.reason = "No sync history found. Run `prjct sync` to initialize.";
@@ -20090,6 +20299,49 @@ var init_staleness_checker = __esm({
         }
         return lines.join("\n");
       }
+      /**
+       * Get session info for the project
+       */
+      async getSessionInfo(projectId) {
+        return sessionTracker.getInfo(projectId);
+      }
+      /**
+       * Format session info for display
+       */
+      formatSessionInfo(info) {
+        const lines = [];
+        if (!info.active) {
+          lines.push("Session: \u25CB No active session");
+          return lines.join("\n");
+        }
+        lines.push(`Session: \u25B6 Active (${info.duration})`);
+        const details = [];
+        if (info.commandCount > 0) {
+          const seen = /* @__PURE__ */ new Set();
+          const unique = [];
+          for (const cmd of info.commands) {
+            if (!seen.has(cmd)) {
+              seen.add(cmd);
+              unique.push(cmd);
+            }
+          }
+          details.push(`Commands:       ${unique.join(" \u2192 ")} (${info.commandCount} total)`);
+        }
+        if (info.filesRead > 0 || info.filesWritten > 0) {
+          details.push(`Files:          ${info.filesRead} read, ${info.filesWritten} written`);
+        }
+        details.push(`Idle:           ${info.expiresIn} until timeout`);
+        if (details.length > 0) {
+          const maxLen = Math.max(...details.map((l) => l.length));
+          const border = "\u2500".repeat(maxLen + 2);
+          lines.push(`\u250C${border}\u2510`);
+          for (const detail of details) {
+            lines.push(`\u2502 ${detail.padEnd(maxLen)} \u2502`);
+          }
+          lines.push(`\u2514${border}\u2518`);
+        }
+        return lines.join("\n");
+      }
       /**
        * Get a short warning message if stale (for other commands)
        */
@@ -20338,9 +20590,9 @@ var init_formatters = __esm({
 
 // core/ai-tools/registry.ts
 import { execSync as execSync4 } from "node:child_process";
-import fs38 from "node:fs";
+import fs39 from "node:fs";
 import os11 from "node:os";
-import path40 from "node:path";
+import path41 from "node:path";
 function getAIToolConfig(id) {
   return AI_TOOLS[id] || null;
 }
@@ -20357,16 +20609,16 @@ function detectInstalledTools(repoPath = process.cwd()) {
   if (commandExists("claude")) {
     detected.push("claude");
   }
-  if (commandExists("cursor") || fs38.existsSync(path40.join(repoPath, ".cursor"))) {
+  if (commandExists("cursor") || fs39.existsSync(path41.join(repoPath, ".cursor"))) {
     detected.push("cursor");
   }
-  if (fs38.existsSync(path40.join(repoPath, ".github"))) {
+  if (fs39.existsSync(path41.join(repoPath, ".github"))) {
     detected.push("copilot");
   }
-  if (commandExists("windsurf") || fs38.existsSync(path40.join(repoPath, ".windsurf"))) {
+  if (commandExists("windsurf") || fs39.existsSync(path41.join(repoPath, ".windsurf"))) {
     detected.push("windsurf");
   }
-  if (fs38.existsSync(path40.join(repoPath, ".continue")) || fs38.existsSync(path40.join(os11.homedir(), ".continue"))) {
+  if (fs39.existsSync(path41.join(repoPath, ".continue")) || fs39.existsSync(path41.join(os11.homedir(), ".continue"))) {
     detected.push("continue");
   }
   return detected;
@@ -20442,8 +20694,8 @@ var init_registry = __esm({
 });
 
 // core/ai-tools/generator.ts
-import fs39 from "node:fs/promises";
-import path41 from "node:path";
+import fs40 from "node:fs/promises";
+import path42 from "node:path";
 async function generateAIToolContexts(context2, globalPath, repoPath, toolIds = DEFAULT_AI_TOOLS) {
   const results = [];
   for (const toolId of toolIds) {
@@ -20478,13 +20730,13 @@ async function generateForTool(context2, config, globalPath, repoPath) {
     let content = formatter(context2, config);
     let outputPath;
     if (config.outputPath === "repo") {
-      outputPath = path41.join(repoPath, config.outputFile);
+      outputPath = path42.join(repoPath, config.outputFile);
     } else {
-      outputPath = path41.join(globalPath, "context", config.outputFile);
+      outputPath = path42.join(globalPath, "context", config.outputFile);
     }
-    await fs39.mkdir(path41.dirname(outputPath), { recursive: true });
+    await fs40.mkdir(path42.dirname(outputPath), { recursive: true });
     try {
-      const existingContent = await fs39.readFile(outputPath, "utf-8");
+      const existingContent = await fs40.readFile(outputPath, "utf-8");
       const validation = validatePreserveBlocks(existingContent);
       if (!validation.valid) {
         console.warn(`\u26A0\uFE0F  ${config.outputFile} has invalid preserve blocks:`);
@@ -20495,7 +20747,7 @@ async function generateForTool(context2, config, globalPath, repoPath) {
       content = mergePreservedSections(content, existingContent);
     } catch {
     }
-    await fs39.writeFile(outputPath, content, "utf-8");
+    await fs40.writeFile(outputPath, content, "utf-8");
     return {
       toolId: config.id,
       outputFile: config.outputFile,
@@ -20534,8 +20786,8 @@ var init_ai_tools = __esm({
 });
 
 // core/services/context-generator.ts
-import fs40 from "node:fs/promises";
-import path42 from "node:path";
+import fs41 from "node:fs/promises";
+import path43 from "node:path";
 var ContextFileGenerator;
 var init_context_generator = __esm({
   "core/services/context-generator.ts"() {
@@ -20559,10 +20811,10 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs40.readFile(filePath, "utf-8");
+          const existingContent = await fs41.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
-            const filename = path42.basename(filePath);
+            const filename = path43.basename(filePath);
             console.warn(`\u26A0\uFE0F  ${filename} has invalid preserve blocks:`);
             for (const error of validation.errors) {
               console.warn(`   ${error}`);
@@ -20571,13 +20823,13 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs40.writeFile(filePath, finalContent, "utf-8");
+        await fs41.writeFile(filePath, finalContent, "utf-8");
       }
       /**
        * Generate all context files in parallel
        */
       async generate(git, stats, commands, agents) {
-        const contextPath = path42.join(this.config.globalPath, "context");
+        const contextPath = path43.join(this.config.globalPath, "context");
         await Promise.all([
           this.generateClaudeMd(contextPath, git, stats, commands, agents),
           this.generateNowMd(contextPath),
@@ -20671,7 +20923,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        const claudePath = path42.join(contextPath, "CLAUDE.md");
+        const claudePath = path43.join(contextPath, "CLAUDE.md");
         await this.writeWithPreservation(claudePath, content);
       }
       /**
@@ -20680,8 +20932,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path42.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs40.readFile(statePath, "utf-8"));
+          const statePath = path43.join(this.config.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs41.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -20697,7 +20949,7 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await this.writeWithPreservation(path42.join(contextPath, "now.md"), content);
+        await this.writeWithPreservation(path43.join(contextPath, "now.md"), content);
       }
       /**
        * Generate next.md - task queue
@@ -20705,15 +20957,15 @@ Use \`p. task "description"\` to start working.
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path42.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs40.readFile(queuePath, "utf-8"));
+          const queuePath = path43.join(this.config.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs41.readFile(queuePath, "utf-8"));
         } catch {
         }
         const content = `# NEXT
 
 ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ""}`).join("\n") : "_Empty queue_"}
 `;
-        await this.writeWithPreservation(path42.join(contextPath, "next.md"), content);
+        await this.writeWithPreservation(path43.join(contextPath, "next.md"), content);
       }
       /**
        * Generate ideas.md - captured ideas
@@ -20721,15 +20973,15 @@ ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}
       async generateIdeasMd(contextPath) {
         let ideas = { ideas: [] };
         try {
-          const ideasPath = path42.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs40.readFile(ideasPath, "utf-8"));
+          const ideasPath = path43.join(this.config.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs41.readFile(ideasPath, "utf-8"));
         } catch {
         }
         const content = `# IDEAS
 
 ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [${i.priority}]` : ""}`).join("\n") : "_No ideas captured yet_"}
 `;
-        await this.writeWithPreservation(path42.join(contextPath, "ideas.md"), content);
+        await this.writeWithPreservation(path43.join(contextPath, "ideas.md"), content);
       }
       /**
        * Generate shipped.md - completed features
@@ -20739,8 +20991,8 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
           shipped: []
         };
         try {
-          const shippedPath = path42.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs40.readFile(shippedPath, "utf-8"));
+          const shippedPath = path43.join(this.config.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs41.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -20749,7 +21001,7 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await this.writeWithPreservation(path42.join(contextPath, "shipped.md"), content);
+        await this.writeWithPreservation(path43.join(contextPath, "shipped.md"), content);
       }
       // ==========================================================================
       // MONOREPO SUPPORT
@@ -20778,9 +21030,9 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
             commands,
             agents
           );
-          const claudePath = path42.join(pkg.path, "CLAUDE.md");
+          const claudePath = path43.join(pkg.path, "CLAUDE.md");
           await this.writeWithPreservation(claudePath, content);
-          generatedFiles.push(path42.relative(this.config.projectPath, claudePath));
+          generatedFiles.push(path43.relative(this.config.projectPath, claudePath));
         }
         return generatedFiles;
       }
@@ -20793,8 +21045,8 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
         let pkgVersion = stats.version;
         let pkgName = pkg.name;
         try {
-          const pkgJsonPath = path42.join(pkg.path, "package.json");
-          const pkgJson = JSON.parse(await fs40.readFile(pkgJsonPath, "utf-8"));
+          const pkgJsonPath = path43.join(pkg.path, "package.json");
+          const pkgJson = JSON.parse(await fs41.readFile(pkgJsonPath, "utf-8"));
           pkgVersion = pkgJson.version || stats.version;
           pkgName = pkgJson.name || pkg.name;
         } catch {
@@ -20859,8 +21111,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 });
 
 // core/services/local-state-generator.ts
-import fs41 from "node:fs/promises";
-import path43 from "node:path";
+import fs42 from "node:fs/promises";
+import path44 from "node:path";
 var LOCAL_STATE_FILENAME, LocalStateGenerator, localStateGenerator;
 var init_local_state_generator = __esm({
   "core/services/local-state-generator.ts"() {
@@ -20875,17 +21127,17 @@ var init_local_state_generator = __esm({
        * Generate .prjct-state.md in the project root
        */
       async generate(projectPath, state) {
-        const filePath = path43.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path44.join(projectPath, LOCAL_STATE_FILENAME);
         const content = this.toMarkdown(state);
-        await fs41.writeFile(filePath, content, "utf-8");
+        await fs42.writeFile(filePath, content, "utf-8");
       }
       /**
        * Remove local state file
        */
       async remove(projectPath) {
-        const filePath = path43.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path44.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs41.unlink(filePath);
+          await fs42.unlink(filePath);
         } catch (error) {
           if (!isNotFoundError(error)) throw error;
         }
@@ -20894,9 +21146,9 @@ var init_local_state_generator = __esm({
        * Check if local state file exists
        */
       async exists(projectPath) {
-        const filePath = path43.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path44.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs41.access(filePath);
+          await fs42.access(filePath);
           return true;
         } catch {
           return false;
@@ -20975,8 +21227,8 @@ var init_local_state_generator = __esm({
 });
 
 // core/services/stack-detector.ts
-import fs42 from "node:fs/promises";
-import path44 from "node:path";
+import fs43 from "node:fs/promises";
+import path45 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -21135,8 +21387,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path44.join(this.projectPath, "package.json");
-          const content = await fs42.readFile(pkgPath, "utf-8");
+          const pkgPath = path45.join(this.projectPath, "package.json");
+          const content = await fs43.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -21147,7 +21399,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs42.access(path44.join(this.projectPath, filename));
+          await fs43.access(path45.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -21159,8 +21411,8 @@ var init_stack_detector = __esm({
 
 // core/services/sync-service.ts
 import { exec as exec12 } from "node:child_process";
-import fs43 from "node:fs/promises";
-import path45 from "node:path";
+import fs44 from "node:fs/promises";
+import path46 from "node:path";
 import { promisify as promisify12 } from "node:util";
 var execAsync7, SyncService, syncService;
 var init_sync_service = __esm({
@@ -21313,7 +21565,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs43.mkdir(path45.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs44.mkdir(path46.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -21383,7 +21635,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path45.basename(this.projectPath),
+          name: path46.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -21399,8 +21651,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path45.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs43.readFile(pkgPath, "utf-8"));
+          const pkgPath = path46.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs44.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -21508,12 +21760,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path45.join(this.globalPath, "agents");
+        const agentsPath = path46.join(this.globalPath, "agents");
         try {
-          const files = await fs43.readdir(agentsPath);
+          const files = await fs44.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs43.unlink(path45.join(agentsPath, file));
+              await fs44.unlink(path46.join(agentsPath, file));
             }
           }
         } catch {
@@ -21553,7 +21805,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path45.join(
+          const templatePath = path46.join(
             __dirname,
             "..",
             "..",
@@ -21562,16 +21814,16 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs43.readFile(templatePath, "utf-8");
+          content = await fs44.readFile(templatePath, "utf-8");
         } catch {
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs43.writeFile(path45.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs44.writeFile(path46.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path45.join(
+          const templatePath = path46.join(
             __dirname,
             "..",
             "..",
@@ -21580,14 +21832,14 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs43.readFile(templatePath, "utf-8");
+          content = await fs44.readFile(templatePath, "utf-8");
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
           content = content.replace("{ecosystem}", stats.ecosystem);
         } catch {
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs43.writeFile(path45.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs44.writeFile(path46.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -21655,8 +21907,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
           })),
           agentSkillMap: Object.fromEntries(skills.map((s) => [s.agent, s.skill]))
         };
-        fs43.writeFile(
-          path45.join(this.globalPath, "config", "skills.json"),
+        fs44.writeFile(
+          path46.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch(() => {
@@ -21678,10 +21930,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path45.join(this.globalPath, "project.json");
+        const projectJsonPath = path46.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs43.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs44.readFile(projectJsonPath, "utf-8"));
         } catch {
         }
         const updated = {
@@ -21703,16 +21955,16 @@ You are the ${name} expert for this project. Apply best practices for the detect
           lastSyncCommit: git.recentCommits[0]?.hash || null,
           lastSyncBranch: git.branch
         };
-        await fs43.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs44.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path45.join(this.globalPath, "storage", "state.json");
+        const statePath = path46.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs43.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs44.readFile(statePath, "utf-8"));
         } catch {
         }
         state.projectId = this.projectId;
@@ -21739,7 +21991,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           lastAction: "Synced project",
           nextAction: 'Run `p. task "description"` to start working'
         };
-        await fs43.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs44.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
         try {
           await localStateGenerator.generate(
             this.projectPath,
@@ -21752,7 +22004,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path45.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path46.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: date_helper_default.getTimestamp(),
           action: "sync",
@@ -21761,7 +22013,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs43.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs44.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -21781,16 +22033,16 @@ You are the ${name} expert for this project. Apply best practices for the detect
         let filteredChars = 0;
         for (const file of contextFiles) {
           try {
-            const filePath = path45.join(this.globalPath, file);
-            const content = await fs43.readFile(filePath, "utf-8");
+            const filePath = path46.join(this.globalPath, file);
+            const content = await fs44.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
         }
         for (const agent of agents) {
           try {
-            const agentPath = path45.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs43.readFile(agentPath, "utf-8");
+            const agentPath = path46.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs44.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
@@ -21822,7 +22074,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs43.access(path45.join(this.projectPath, filename));
+          await fs44.access(path46.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -21830,8 +22082,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path45.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs43.readFile(pkgPath, "utf-8"));
+          const pkgPath = path46.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs44.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch {
           return "0.0.0";
@@ -21992,22 +22244,22 @@ __export(uninstall_exports, {
 });
 import { execSync as execSync5 } from "node:child_process";
 import fsSync2 from "node:fs";
-import fs44 from "node:fs/promises";
+import fs45 from "node:fs/promises";
 import os12 from "node:os";
-import path46 from "node:path";
+import path47 from "node:path";
 import readline2 from "node:readline";
 import chalk12 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs44.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs45.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path46.join(dirPath, entry.name);
+      const entryPath = path47.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs44.stat(entryPath);
+          const stats = await fs45.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -22026,7 +22278,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs44.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs45.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -22059,7 +22311,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = fsSync2.existsSync(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path46.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path47.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -22069,7 +22321,7 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path46.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path47.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = fsSync2.existsSync(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
@@ -22103,7 +22355,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path46.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path47.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = fsSync2.existsSync(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -22119,7 +22371,7 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path46.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path47.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = fsSync2.existsSync(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
@@ -22141,7 +22393,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs44.readFile(filePath, "utf-8");
+    const content = await fs45.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -22150,9 +22402,9 @@ async function removePrjctSection(filePath) {
     let newContent = content.substring(0, startIndex) + content.substring(endIndex);
     newContent = newContent.replace(/\n{3,}/g, "\n\n").trim();
     if (!newContent || newContent.trim().length === 0) {
-      await fs44.unlink(filePath);
+      await fs45.unlink(filePath);
     } else {
-      await fs44.writeFile(filePath, `${newContent}
+      await fs45.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -22163,12 +22415,12 @@ async function removePrjctSection(filePath) {
 async function createBackup() {
   const homeDir = os12.homedir();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
-  const backupDir = path46.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path47.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs44.mkdir(backupDir, { recursive: true });
+    await fs45.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (fsSync2.existsSync(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path46.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path47.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -22176,15 +22428,15 @@ async function createBackup() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs44.mkdir(dest, { recursive: true });
-  const entries = await fs44.readdir(src, { withFileTypes: true });
+  await fs45.mkdir(dest, { recursive: true });
+  const entries = await fs45.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path46.join(src, entry.name);
-    const destPath = path46.join(dest, entry.name);
+    const srcPath = path47.join(src, entry.name);
+    const destPath = path47.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs44.copyFile(srcPath, destPath);
+      await fs45.copyFile(srcPath, destPath);
     }
   }
 }
@@ -22200,10 +22452,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs44.rm(item.path, { recursive: true, force: true });
+        await fs45.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs44.unlink(item.path);
+        await fs45.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -22378,7 +22630,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path47 from "node:path";
+import path48 from "node:path";
 import chalk13 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -22583,7 +22835,7 @@ ${chalk13.dim(`[${timestamp}]`)} ${chalk13.cyan("\u27F3")} ${filesSummary} chang
       printStartup() {
         console.log("");
         console.log(chalk13.cyan("\u{1F441}\uFE0F  Watching for changes..."));
-        console.log(chalk13.dim(`   Project: ${path47.basename(this.projectPath)}`));
+        console.log(chalk13.dim(`   Project: ${path48.basename(this.projectPath)}`));
         console.log(chalk13.dim(`   Debounce: ${this.options.debounceMs}ms`));
         console.log(chalk13.dim(`   Min interval: ${this.options.minIntervalMs / 1e3}s`));
         console.log("");
@@ -23261,9 +23513,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync6 } from "node:child_process";
-import fs45 from "node:fs";
+import fs46 from "node:fs";
 import os13 from "node:os";
-import path48 from "node:path";
+import path49 from "node:path";
 import chalk15 from "chalk";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
@@ -23402,12 +23654,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path48.join(os13.homedir(), ".gemini", "commands");
-    const routerSource = path48.join(getPackageRoot(), "templates", "commands", "p.toml");
-    const routerDest = path48.join(geminiCommandsDir, "p.toml");
-    fs45.mkdirSync(geminiCommandsDir, { recursive: true });
-    if (fs45.existsSync(routerSource)) {
-      fs45.copyFileSync(routerSource, routerDest);
+    const geminiCommandsDir = path49.join(os13.homedir(), ".gemini", "commands");
+    const routerSource = path49.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = path49.join(geminiCommandsDir, "p.toml");
+    fs46.mkdirSync(geminiCommandsDir, { recursive: true });
+    if (fs46.existsSync(routerSource)) {
+      fs46.copyFileSync(routerSource, routerDest);
       return true;
     }
     return false;
@@ -23418,15 +23670,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path48.join(os13.homedir(), ".gemini");
-    const globalConfigPath = path48.join(geminiDir, "GEMINI.md");
-    const templatePath = path48.join(getPackageRoot(), "templates", "global", "GEMINI.md");
-    fs45.mkdirSync(geminiDir, { recursive: true });
-    const templateContent = fs45.readFileSync(templatePath, "utf-8");
+    const geminiDir = path49.join(os13.homedir(), ".gemini");
+    const globalConfigPath = path49.join(geminiDir, "GEMINI.md");
+    const templatePath = path49.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    fs46.mkdirSync(geminiDir, { recursive: true });
+    const templateContent = fs46.readFileSync(templatePath, "utf-8");
     let existingContent = "";
     let fileExists2 = false;
     try {
-      existingContent = fs45.readFileSync(globalConfigPath, "utf-8");
+      existingContent = fs46.readFileSync(globalConfigPath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -23436,7 +23688,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!fileExists2) {
-      fs45.writeFileSync(globalConfigPath, templateContent, "utf-8");
+      fs46.writeFileSync(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -23446,7 +23698,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      fs45.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
+      fs46.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -23458,7 +23710,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    fs45.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    fs46.writeFileSync(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -23467,18 +23719,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path48.join(os13.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = path48.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = path48.join(prjctSkillDir, "SKILL.md");
-    const templatePath = path48.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
-    fs45.mkdirSync(prjctSkillDir, { recursive: true });
-    const fileExists2 = fs45.existsSync(skillMdPath);
-    if (!fs45.existsSync(templatePath)) {
+    const antigravitySkillsDir = path49.join(os13.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path49.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path49.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path49.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    fs46.mkdirSync(prjctSkillDir, { recursive: true });
+    const fileExists2 = fs46.existsSync(skillMdPath);
+    if (!fs46.existsSync(templatePath)) {
       console.error("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = fs45.readFileSync(templatePath, "utf-8");
-    fs45.writeFileSync(skillMdPath, templateContent, "utf-8");
+    const templateContent = fs46.readFileSync(templatePath, "utf-8");
+    fs46.writeFileSync(skillMdPath, templateContent, "utf-8");
     return { success: true, action: fileExists2 ? "updated" : "created" };
   } catch (error) {
     console.error(`Antigravity skill warning: ${error.message}`);
@@ -23497,24 +23749,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = path48.join(projectRoot, ".cursor");
-    const rulesDir = path48.join(cursorDir, "rules");
-    const commandsDir = path48.join(cursorDir, "commands");
-    const routerMdcDest = path48.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = path48.join(getPackageRoot(), "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = path48.join(getPackageRoot(), "templates", "cursor", "commands");
-    fs45.mkdirSync(rulesDir, { recursive: true });
-    fs45.mkdirSync(commandsDir, { recursive: true });
-    if (fs45.existsSync(routerMdcSource)) {
-      fs45.copyFileSync(routerMdcSource, routerMdcDest);
+    const cursorDir = path49.join(projectRoot, ".cursor");
+    const rulesDir = path49.join(cursorDir, "rules");
+    const commandsDir = path49.join(cursorDir, "commands");
+    const routerMdcDest = path49.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path49.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path49.join(getPackageRoot(), "templates", "cursor", "commands");
+    fs46.mkdirSync(rulesDir, { recursive: true });
+    fs46.mkdirSync(commandsDir, { recursive: true });
+    if (fs46.existsSync(routerMdcSource)) {
+      fs46.copyFileSync(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
-    if (fs45.existsSync(cursorCommandsSource)) {
-      const commandFiles = fs45.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
+    if (fs46.existsSync(cursorCommandsSource)) {
+      const commandFiles = fs46.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path48.join(cursorCommandsSource, file);
-        const dest = path48.join(commandsDir, file);
-        fs45.copyFileSync(src, dest);
+        const src = path49.join(cursorCommandsSource, file);
+        const dest = path49.join(commandsDir, file);
+        fs46.copyFileSync(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -23528,7 +23780,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path48.join(projectRoot, ".gitignore");
+    const gitignorePath = path49.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -23543,7 +23795,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs45.readFileSync(gitignorePath, "utf-8");
+      content = fs46.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -23558,7 +23810,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs45.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs46.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -23566,12 +23818,12 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasCursorProject(projectRoot) {
-  return fs45.existsSync(path48.join(projectRoot, ".cursor"));
+  return fs46.existsSync(path49.join(projectRoot, ".cursor"));
 }
 function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path48.join(projectRoot, ".cursor");
-  const routerPath = path48.join(cursorDir, "rules", "prjct.mdc");
-  return fs45.existsSync(cursorDir) && !fs45.existsSync(routerPath);
+  const cursorDir = path49.join(projectRoot, ".cursor");
+  const routerPath = path49.join(cursorDir, "rules", "prjct.mdc");
+  return fs46.existsSync(cursorDir) && !fs46.existsSync(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
   const result = {
@@ -23581,29 +23833,29 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = path48.join(projectRoot, ".windsurf");
-    const rulesDir = path48.join(windsurfDir, "rules");
-    const workflowsDir = path48.join(windsurfDir, "workflows");
-    const routerDest = path48.join(rulesDir, "prjct.md");
-    const routerSource = path48.join(getPackageRoot(), "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = path48.join(
+    const windsurfDir = path49.join(projectRoot, ".windsurf");
+    const rulesDir = path49.join(windsurfDir, "rules");
+    const workflowsDir = path49.join(windsurfDir, "workflows");
+    const routerDest = path49.join(rulesDir, "prjct.md");
+    const routerSource = path49.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path49.join(
       getPackageRoot(),
       "templates",
       "windsurf",
       "workflows"
     );
-    fs45.mkdirSync(rulesDir, { recursive: true });
-    fs45.mkdirSync(workflowsDir, { recursive: true });
-    if (fs45.existsSync(routerSource)) {
-      fs45.copyFileSync(routerSource, routerDest);
+    fs46.mkdirSync(rulesDir, { recursive: true });
+    fs46.mkdirSync(workflowsDir, { recursive: true });
+    if (fs46.existsSync(routerSource)) {
+      fs46.copyFileSync(routerSource, routerDest);
       result.rulesCreated = true;
     }
-    if (fs45.existsSync(windsurfWorkflowsSource)) {
-      const workflowFiles = fs45.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
+    if (fs46.existsSync(windsurfWorkflowsSource)) {
+      const workflowFiles = fs46.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
       for (const file of workflowFiles) {
-        const src = path48.join(windsurfWorkflowsSource, file);
-        const dest = path48.join(workflowsDir, file);
-        fs45.copyFileSync(src, dest);
+        const src = path49.join(windsurfWorkflowsSource, file);
+        const dest = path49.join(workflowsDir, file);
+        fs46.copyFileSync(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -23617,7 +23869,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path48.join(projectRoot, ".gitignore");
+    const gitignorePath = path49.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -23632,7 +23884,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs45.readFileSync(gitignorePath, "utf-8");
+      content = fs46.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -23647,7 +23899,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs45.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs46.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -23655,32 +23907,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasWindsurfProject(projectRoot) {
-  return fs45.existsSync(path48.join(projectRoot, ".windsurf"));
+  return fs46.existsSync(path49.join(projectRoot, ".windsurf"));
 }
 function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path48.join(projectRoot, ".windsurf");
-  const routerPath = path48.join(windsurfDir, "rules", "prjct.md");
-  return fs45.existsSync(windsurfDir) && !fs45.existsSync(routerPath);
+  const windsurfDir = path49.join(projectRoot, ".windsurf");
+  const routerPath = path49.join(windsurfDir, "rules", "prjct.md");
+  return fs46.existsSync(windsurfDir) && !fs46.existsSync(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path48.join(os13.homedir(), ".prjct-cli", "projects");
-    if (!fs45.existsSync(projectsDir)) {
+    const projectsDir = path49.join(os13.homedir(), ".prjct-cli", "projects");
+    if (!fs46.existsSync(projectsDir)) {
       return;
     }
-    const projectDirs = fs45.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = fs46.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path48.join(projectsDir, projectId, "project.json");
-      if (!fs45.existsSync(projectJsonPath)) {
+      const projectJsonPath = path49.join(projectsDir, projectId, "project.json");
+      if (!fs46.existsSync(projectJsonPath)) {
         continue;
       }
       try {
-        const content = fs45.readFileSync(projectJsonPath, "utf8");
+        const content = fs46.readFileSync(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          fs45.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          fs46.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -23700,9 +23952,9 @@ async function migrateProjectsCliVersion() {
 }
 function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
-  if (fs45.existsSync(settingsPath)) {
+  if (fs46.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs45.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(fs46.readFileSync(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -23710,42 +23962,42 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  fs45.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  fs46.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path48.join(os13.homedir(), ".claude");
-    const settingsPath = path48.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = path48.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path48.join(os13.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = path48.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = path48.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = path48.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = path48.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = path48.join(prjctStatusLineDir, "config.json");
-    const assetsDir = path48.join(getPackageRoot(), "assets", "statusline");
-    const sourceScript = path48.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = path48.join(assetsDir, "themes");
-    const sourceLibDir = path48.join(assetsDir, "lib");
-    const sourceComponentsDir = path48.join(assetsDir, "components");
-    const sourceConfigPath = path48.join(assetsDir, "default-config.json");
-    if (!fs45.existsSync(claudeDir)) {
-      fs45.mkdirSync(claudeDir, { recursive: true });
-    }
-    if (!fs45.existsSync(prjctStatusLineDir)) {
-      fs45.mkdirSync(prjctStatusLineDir, { recursive: true });
-    }
-    if (!fs45.existsSync(prjctThemesDir)) {
-      fs45.mkdirSync(prjctThemesDir, { recursive: true });
-    }
-    if (!fs45.existsSync(prjctLibDir)) {
-      fs45.mkdirSync(prjctLibDir, { recursive: true });
-    }
-    if (!fs45.existsSync(prjctComponentsDir)) {
-      fs45.mkdirSync(prjctComponentsDir, { recursive: true });
-    }
-    if (fs45.existsSync(prjctStatusLinePath)) {
-      const existingContent = fs45.readFileSync(prjctStatusLinePath, "utf8");
+    const claudeDir = path49.join(os13.homedir(), ".claude");
+    const settingsPath = path49.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path49.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path49.join(os13.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path49.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path49.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path49.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path49.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path49.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path49.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = path49.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path49.join(assetsDir, "themes");
+    const sourceLibDir = path49.join(assetsDir, "lib");
+    const sourceComponentsDir = path49.join(assetsDir, "components");
+    const sourceConfigPath = path49.join(assetsDir, "default-config.json");
+    if (!fs46.existsSync(claudeDir)) {
+      fs46.mkdirSync(claudeDir, { recursive: true });
+    }
+    if (!fs46.existsSync(prjctStatusLineDir)) {
+      fs46.mkdirSync(prjctStatusLineDir, { recursive: true });
+    }
+    if (!fs46.existsSync(prjctThemesDir)) {
+      fs46.mkdirSync(prjctThemesDir, { recursive: true });
+    }
+    if (!fs46.existsSync(prjctLibDir)) {
+      fs46.mkdirSync(prjctLibDir, { recursive: true });
+    }
+    if (!fs46.existsSync(prjctComponentsDir)) {
+      fs46.mkdirSync(prjctComponentsDir, { recursive: true });
+    }
+    if (fs46.existsSync(prjctStatusLinePath)) {
+      const existingContent = fs46.readFileSync(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -23753,7 +24005,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          fs45.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+          fs46.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         installStatusLineModules(sourceLibDir, prjctLibDir);
         installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -23762,22 +24014,22 @@ async function installStatusLine() {
         return;
       }
     }
-    if (fs45.existsSync(sourceScript)) {
-      let scriptContent = fs45.readFileSync(sourceScript, "utf8");
+    if (fs46.existsSync(sourceScript)) {
+      let scriptContent = fs46.readFileSync(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      fs45.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs46.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
       installStatusLineModules(sourceLibDir, prjctLibDir);
       installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (fs45.existsSync(sourceThemeDir)) {
-        const themes = fs45.readdirSync(sourceThemeDir);
+      if (fs46.existsSync(sourceThemeDir)) {
+        const themes = fs46.readdirSync(sourceThemeDir);
         for (const theme of themes) {
-          const src = path48.join(sourceThemeDir, theme);
-          const dest = path48.join(prjctThemesDir, theme);
-          fs45.copyFileSync(src, dest);
+          const src = path49.join(sourceThemeDir, theme);
+          const dest = path49.join(prjctThemesDir, theme);
+          fs46.copyFileSync(src, dest);
         }
       }
-      if (!fs45.existsSync(prjctConfigPath) && fs45.existsSync(sourceConfigPath)) {
-        fs45.copyFileSync(sourceConfigPath, prjctConfigPath);
+      if (!fs46.existsSync(prjctConfigPath) && fs46.existsSync(sourceConfigPath)) {
+        fs46.copyFileSync(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -23812,7 +24064,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      fs45.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs46.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -23824,10 +24076,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path48.join(os13.homedir(), ".claude");
-    const mcpConfigPath = path48.join(claudeDir, "mcp.json");
-    if (!fs45.existsSync(claudeDir)) {
-      fs45.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = path49.join(os13.homedir(), ".claude");
+    const mcpConfigPath = path49.join(claudeDir, "mcp.json");
+    if (!fs46.existsSync(claudeDir)) {
+      fs46.mkdirSync(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -23837,54 +24089,54 @@ async function installContext7MCP() {
         }
       }
     };
-    if (fs45.existsSync(mcpConfigPath)) {
-      const existingContent = fs45.readFileSync(mcpConfigPath, "utf-8");
+    if (fs46.existsSync(mcpConfigPath)) {
+      const existingContent = fs46.readFileSync(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      fs45.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      fs46.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      fs45.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      fs46.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     console.error(`Context7 MCP setup warning: ${error.message}`);
   }
 }
 function installStatusLineModules(sourceDir, destDir) {
-  if (!fs45.existsSync(sourceDir)) {
+  if (!fs46.existsSync(sourceDir)) {
     return;
   }
-  const files = fs45.readdirSync(sourceDir);
+  const files = fs46.readdirSync(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path48.join(sourceDir, file);
-      const dest = path48.join(destDir, file);
-      fs45.copyFileSync(src, dest);
-      fs45.chmodSync(dest, 493);
+      const src = path49.join(sourceDir, file);
+      const dest = path49.join(destDir, file);
+      fs46.copyFileSync(src, dest);
+      fs46.chmodSync(dest, 493);
     }
   }
 }
 function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
-    if (fs45.existsSync(linkPath)) {
-      const stats = fs45.lstatSync(linkPath);
+    if (fs46.existsSync(linkPath)) {
+      const stats = fs46.lstatSync(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = fs45.readlinkSync(linkPath);
+        const existingTarget = fs46.readlinkSync(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      fs45.unlinkSync(linkPath);
+      fs46.unlinkSync(linkPath);
     }
-    fs45.symlinkSync(targetPath, linkPath);
+    fs46.symlinkSync(targetPath, linkPath);
   } catch (_error) {
     try {
-      if (fs45.existsSync(targetPath)) {
-        fs45.copyFileSync(targetPath, linkPath);
-        fs45.chmodSync(linkPath, 493);
+      if (fs46.existsSync(targetPath)) {
+        fs46.copyFileSync(targetPath, linkPath);
+        fs46.chmodSync(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -24297,7 +24549,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path49 from "node:path";
+import path50 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -24323,7 +24575,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path49.basename(projectPath);
+          const projectName = path50.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -24575,8 +24827,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs46 from "node:fs/promises";
-import path50 from "node:path";
+import fs47 from "node:fs/promises";
+import path51 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -24702,8 +24954,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path50.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs46.readFile(analysisPath, "utf-8");
+          const analysisPath = path51.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs47.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -24722,7 +24974,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path51 from "node:path";
+import path52 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -24738,7 +24990,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path51.basename(filePath));
+          results.rotated.push(path52.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -24845,7 +25097,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path52 from "node:path";
+import path53 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -24857,7 +25109,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 = path52.join(
+    const designsPath = path53.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -24897,7 +25149,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path52.join(designsPath, designFileName);
+    const designFilePath = path53.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -24921,7 +25173,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path53 from "node:path";
+import path54 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -24973,7 +25225,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path53.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path54.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync7 } = await import("node:child_process");
     try {
@@ -24991,7 +25243,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path53.join(snapshotsPath, "history.json");
+      const snapshotFile = path54.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -25031,8 +25283,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path53.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path53.join(snapshotsPath, "history.json");
+    const snapshotsPath = path54.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path54.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -25091,8 +25343,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path53.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path53.join(snapshotsPath, "history.json");
+    const snapshotsPath = path54.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path54.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -25199,8 +25451,8 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import fs47 from "node:fs";
-import path54 from "node:path";
+import fs48 from "node:fs";
+import path55 from "node:path";
 import chalk16 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -25327,7 +25579,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path54.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path55.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -25385,11 +25637,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs47.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs48.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs47.existsSync(settingsPath)) {
+          if (fs48.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs47.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs48.readFileSync(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -25397,7 +25649,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs47.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs48.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -25453,18 +25705,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path55 from "node:path";
+import path56 from "node:path";
 async function detectPackageManager(projectPath, pkg) {
   const declared = pkg?.packageManager?.trim().toLowerCase();
   if (declared?.startsWith("pnpm@")) return "pnpm";
   if (declared?.startsWith("yarn@")) return "yarn";
   if (declared?.startsWith("bun@")) return "bun";
   if (declared?.startsWith("npm@")) return "npm";
-  if (await fileExists(path55.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path55.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists(path55.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists(path55.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists(path55.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(path56.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path56.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path56.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path56.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path56.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -25480,7 +25732,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path55.join(projectPath, "package.json");
+  const pkgPath = path56.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -25497,27 +25749,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path55.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path56.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path55.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path56.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path55.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path56.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path55.join(projectPath, "go.mod"))) {
+  if (await fileExists(path56.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(path55.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path56.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path55.join(projectPath, "gradlew")) && (await fileExists(path55.join(projectPath, "build.gradle")) || await fileExists(path55.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path56.join(projectPath, "gradlew")) && (await fileExists(path56.join(projectPath, "build.gradle")) || await fileExists(path56.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -25690,7 +25942,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path56 from "node:path";
+import path57 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -25836,7 +26088,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path56.join(projectPath, "package.json");
+          const pkgPath = path57.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);
@@ -25858,7 +26110,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path56.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path57.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())}
 
@@ -26750,19 +27002,19 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs48 from "node:fs";
+import fs49 from "node:fs";
 import os14 from "node:os";
-import path57 from "node:path";
+import path58 from "node:path";
 function getCredentialsPath(projectId) {
-  return path57.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path58.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
-  if (!fs48.existsSync(credPath)) {
+  if (!fs49.existsSync(credPath)) {
     return {};
   }
   try {
-    return JSON.parse(fs48.readFileSync(credPath, "utf-8"));
+    return JSON.parse(fs49.readFileSync(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", error.message);
     return {};
@@ -27339,7 +27591,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.2.2",
+      version: "1.3.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -27446,9 +27698,9 @@ var require_package = __commonJS({
 
 // core/index.ts
 var core_exports = {};
-import fs49 from "node:fs";
+import fs50 from "node:fs";
 import os15 from "node:os";
-import path58 from "node:path";
+import path59 from "node:path";
 import chalk18 from "chalk";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
@@ -27488,6 +27740,16 @@ Use 'prjct --help' to see available commands.`);
       process.exit(1);
     }
     const { parsedArgs, options } = parseCommandArgs(cmd, rawArgs);
+    let projectId = null;
+    const commandStartTime = Date.now();
+    try {
+      projectId = await config_manager_default.getProjectId(process.cwd());
+      if (projectId) {
+        await sessionTracker.expireIfStale(projectId);
+        await sessionTracker.touch(projectId);
+      }
+    } catch {
+    }
     const commands = new PrjctCommands();
     let result;
     if (commandName === "design") {
@@ -27547,6 +27809,13 @@ Use 'prjct --help' to see available commands.`);
         throw new Error(`Command '${commandName}' has no handler`);
       }
     }
+    if (projectId) {
+      const durationMs = Date.now() - commandStartTime;
+      try {
+        await sessionTracker.trackCommand(projectId, commandName, durationMs);
+      } catch {
+      }
+    }
     if (result?.message) {
       console.log(result.message);
     }
@@ -27581,12 +27850,12 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 function displayVersion(version) {
   const detection = detectAllProviders();
-  const claudeCommandPath = path58.join(os15.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path58.join(os15.homedir(), ".gemini", "commands", "p.toml");
-  const claudeConfigured = fs49.existsSync(claudeCommandPath);
-  const geminiConfigured = fs49.existsSync(geminiCommandPath);
-  const cursorConfigured = fs49.existsSync(path58.join(process.cwd(), ".cursor", "commands", "sync.md"));
-  const cursorExists = fs49.existsSync(path58.join(process.cwd(), ".cursor"));
+  const claudeCommandPath = path59.join(os15.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path59.join(os15.homedir(), ".gemini", "commands", "p.toml");
+  const claudeConfigured = fs50.existsSync(claudeCommandPath);
+  const geminiConfigured = fs50.existsSync(geminiCommandPath);
+  const cursorConfigured = fs50.existsSync(path59.join(process.cwd(), ".cursor", "commands", "sync.md"));
+  const cursorExists = fs50.existsSync(path59.join(process.cwd(), ".cursor"));
   console.log(`
 ${chalk18.cyan("p/")} prjct v${version}
 ${chalk18.dim("Context layer for AI coding agents")}
@@ -27695,6 +27964,8 @@ var init_core = __esm({
     init_registry2();
     init_register();
     init_ai_provider();
+    init_config_manager();
+    init_session_tracker();
     init_output();
     __name(main, "main");
     __name(parseCommandArgs, "parseCommandArgs");
@@ -27714,9 +27985,9 @@ var init_core = __esm({
 init_ai_provider();
 init_config_manager();
 init_editors_config();
-import fs50 from "node:fs";
+import fs51 from "node:fs";
 import os16 from "node:os";
-import path59 from "node:path";
+import path60 from "node:path";
 import chalk19 from "chalk";
 
 // core/server/server.ts
@@ -28459,14 +28730,14 @@ function checkRoutersInstalled() {
   const home = os16.homedir();
   const detection = detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path59.join(home, ".claude", "commands", "p.md");
-    if (!fs50.existsSync(claudeRouter)) {
+    const claudeRouter = path60.join(home, ".claude", "commands", "p.md");
+    if (!fs51.existsSync(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path59.join(home, ".gemini", "commands", "p.toml");
-    if (!fs50.existsSync(geminiRouter)) {
+    const geminiRouter = path60.join(home, ".gemini", "commands", "p.toml");
+    if (!fs51.existsSync(geminiRouter)) {
       return false;
     }
   }
@@ -28484,6 +28755,26 @@ if (isQuietMode2) {
   const { setQuietMode: setQuietMode2 } = await Promise.resolve().then(() => (init_output(), output_exports));
   setQuietMode2(true);
 }
+async function trackSession(command) {
+  const start = Date.now();
+  try {
+    const projectId = await config_manager_default.getProjectId(process.cwd());
+    if (projectId) {
+      const { sessionTracker: sessionTracker2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
+      await sessionTracker2.expireIfStale(projectId);
+      await sessionTracker2.touch(projectId);
+      return () => {
+        const durationMs = Date.now() - start;
+        sessionTracker2.trackCommand(projectId, command, durationMs).catch(() => {
+        });
+      };
+    }
+  } catch {
+  }
+  return () => {
+  };
+}
+__name(trackSession, "trackSession");
 if (args[0] === "start" || args[0] === "setup") {
   const { runStart: runStart2 } = await Promise.resolve().then(() => (init_start(), start_exports));
   await runStart2();
@@ -28513,20 +28804,26 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
+    const done = await trackSession("context");
     const { runContextTool: runContextTool2 } = await Promise.resolve().then(() => (init_context_tools(), context_tools_exports));
     const result = await runContextTool2(args.slice(1), projectId, projectPath);
     console.log(JSON.stringify(result, null, 2));
     process.exitCode = result.tool === "error" ? 1 : 0;
+    done();
   }
 } else if (args[0] === "hooks") {
+  const done = await trackSession("hooks");
   const { hooksService: hooksService2 } = await Promise.resolve().then(() => (init_hooks_service(), hooks_service_exports));
   const subcommand = args[1] || "status";
   const exitCode = await hooksService2.run(process.cwd(), subcommand);
   process.exitCode = exitCode;
+  done();
 } else if (args[0] === "doctor") {
+  const done = await trackSession("doctor");
   const { doctorService: doctorService2 } = await Promise.resolve().then(() => (init_doctor_service(), doctor_service_exports));
   const exitCode = await doctorService2.run(process.cwd());
   process.exitCode = exitCode;
+  done();
 } else if (args[0] === "uninstall") {
   const { uninstall: uninstall2 } = await Promise.resolve().then(() => (init_uninstall(), uninstall_exports));
   const force = args.includes("--force") || args.includes("-f");
@@ -28567,7 +28864,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path59.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path60.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -28586,12 +28883,12 @@ if (args[0] === "start" || args[0] === "setup") {
   const detection = detectAllProviders();
   const home = os16.homedir();
   const cwd = process.cwd();
-  const claudeConfigured = fs50.existsSync(path59.join(home, ".claude", "commands", "p.md"));
-  const geminiConfigured = fs50.existsSync(path59.join(home, ".gemini", "commands", "p.toml"));
-  const cursorDetected = fs50.existsSync(path59.join(cwd, ".cursor"));
-  const cursorConfigured = fs50.existsSync(path59.join(cwd, ".cursor", "rules", "prjct.mdc"));
-  const windsurfDetected = fs50.existsSync(path59.join(cwd, ".windsurf"));
-  const windsurfConfigured = fs50.existsSync(path59.join(cwd, ".windsurf", "rules", "prjct.md"));
+  const claudeConfigured = fs51.existsSync(path60.join(home, ".claude", "commands", "p.md"));
+  const geminiConfigured = fs51.existsSync(path60.join(home, ".gemini", "commands", "p.toml"));
+  const cursorDetected = fs51.existsSync(path60.join(cwd, ".cursor"));
+  const cursorConfigured = fs51.existsSync(path60.join(cwd, ".cursor", "rules", "prjct.mdc"));
+  const windsurfDetected = fs51.existsSync(path60.join(cwd, ".windsurf"));
+  const windsurfConfigured = fs51.existsSync(path60.join(cwd, ".windsurf", "rules", "prjct.md"));
   console.log(`
 ${chalk19.cyan("p/")} prjct v${VERSION}
 ${chalk19.dim("Context layer for AI coding agents")}
@@ -28629,9 +28926,9 @@ ${chalk19.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
 ${chalk19.cyan("https://prjct.app")}
 `);
 } else {
-  const configPath = path59.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path60.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = checkRoutersInstalled();
-  if (!fs50.existsSync(configPath) || !routersInstalled) {
+  if (!fs51.existsSync(configPath) || !routersInstalled) {
     console.log(`
 ${chalk19.cyan.bold("  Welcome to prjct!")}