prjct-cli 1.19.0 → 1.21.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) => (path73) => {
-  var fn = map[path73];
+var __glob = (map) => (path74) => {
+  var fn = map[path74];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path73);
+  throw new Error("Module not found in bundle: " + path74);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -6600,11 +6600,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs61 = await import("node:fs/promises");
-  const path73 = await import("node:path");
-  const fullPath = path73.isAbsolute(filePath) ? filePath : path73.join(projectPath, filePath);
+  const fs62 = await import("node:fs/promises");
+  const path74 = await import("node:path");
+  const fullPath = path74.isAbsolute(filePath) ? filePath : path74.join(projectPath, filePath);
   try {
-    const stat = await fs61.stat(fullPath);
+    const stat = await fs62.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -6671,11 +6671,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs61 = await import("node:fs/promises");
-  const path73 = await import("node:path");
-  const fullPath = path73.isAbsolute(targetPath) ? targetPath : path73.join(projectPath, targetPath);
+  const fs62 = await import("node:fs/promises");
+  const path74 = await import("node:path");
+  const fullPath = path74.isAbsolute(targetPath) ? targetPath : path74.join(projectPath, targetPath);
   try {
-    const stat = await fs61.stat(fullPath);
+    const stat = await fs62.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -9607,11 +9607,301 @@ var init_agents = __esm({
 });
 
 // core/schemas/analysis.ts
+import fs26 from "node:fs/promises";
+import path24 from "node:path";
 import { z as z4 } from "zod";
-var AnalysisStatusSchema, CodePatternSchema, AntiPatternSchema, AnalysisItemSchema, DEFAULT_ANALYSIS;
+async function verifyFrameworks(analysis2, projectPath) {
+  const start = Date.now();
+  if (analysis2.frameworks.length === 0) {
+    return {
+      name: "Framework verification",
+      passed: true,
+      output: "No frameworks declared (skipped)",
+      durationMs: Date.now() - start
+    };
+  }
+  try {
+    const packagePath = path24.join(projectPath, "package.json");
+    const content = await fs26.readFile(packagePath, "utf-8");
+    const pkg = JSON.parse(content);
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    const missing = [];
+    const found = [];
+    for (const framework of analysis2.frameworks) {
+      const frameworkLower = framework.toLowerCase();
+      const exists = Object.keys(allDeps).some((dep) => dep.toLowerCase().includes(frameworkLower));
+      if (exists) {
+        found.push(framework);
+      } else {
+        missing.push(framework);
+      }
+    }
+    if (missing.length === 0) {
+      return {
+        name: "Framework verification",
+        passed: true,
+        output: `${found.length} framework(s) verified in dependencies`,
+        durationMs: Date.now() - start
+      };
+    }
+    return {
+      name: "Framework verification",
+      passed: false,
+      error: `Frameworks not found in dependencies: ${missing.join(", ")}`,
+      durationMs: Date.now() - start
+    };
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return {
+        name: "Framework verification",
+        passed: false,
+        error: "package.json not found (cannot verify frameworks)",
+        durationMs: Date.now() - start
+      };
+    }
+    return {
+      name: "Framework verification",
+      passed: false,
+      error: `Failed to read package.json: ${error instanceof Error ? error.message : "unknown error"}`,
+      durationMs: Date.now() - start
+    };
+  }
+}
+async function verifyLanguages(analysis2, projectPath) {
+  const start = Date.now();
+  if (analysis2.languages.length === 0) {
+    return {
+      name: "Language verification",
+      passed: true,
+      output: "No languages declared (skipped)",
+      durationMs: Date.now() - start
+    };
+  }
+  try {
+    const extensions = await getProjectExtensions(projectPath);
+    const foundExtensions = new Set(extensions);
+    const verified = [];
+    const notFound = [];
+    for (const language of analysis2.languages) {
+      const expectedExts = LANGUAGE_EXTENSIONS[language];
+      if (!expectedExts) {
+        continue;
+      }
+      const hasMatchingFiles = expectedExts.some((ext) => foundExtensions.has(ext));
+      if (hasMatchingFiles) {
+        verified.push(language);
+      } else {
+        notFound.push(language);
+      }
+    }
+    if (notFound.length === 0) {
+      return {
+        name: "Language verification",
+        passed: true,
+        output: `${verified.length} language(s) verified with matching files`,
+        durationMs: Date.now() - start
+      };
+    }
+    return {
+      name: "Language verification",
+      passed: false,
+      error: `Languages without matching files: ${notFound.join(", ")}`,
+      durationMs: Date.now() - start
+    };
+  } catch (error) {
+    return {
+      name: "Language verification",
+      passed: false,
+      error: `Failed to scan project files: ${error instanceof Error ? error.message : "unknown error"}`,
+      durationMs: Date.now() - start
+    };
+  }
+}
+async function verifyPatternLocations(analysis2, projectPath) {
+  const start = Date.now();
+  const patternsWithLocations = analysis2.patterns.filter((p) => p.location);
+  if (patternsWithLocations.length === 0) {
+    return {
+      name: "Pattern location verification",
+      passed: true,
+      output: "No pattern locations specified (skipped)",
+      durationMs: Date.now() - start
+    };
+  }
+  const missing = [];
+  const verified = [];
+  for (const pattern of patternsWithLocations) {
+    const location = pattern.location;
+    const filePath = path24.join(projectPath, location);
+    try {
+      await fs26.access(filePath);
+      verified.push(location);
+    } catch {
+      missing.push(`${pattern.name} (${location})`);
+    }
+  }
+  if (missing.length === 0) {
+    return {
+      name: "Pattern location verification",
+      passed: true,
+      output: `${verified.length} pattern location(s) verified`,
+      durationMs: Date.now() - start
+    };
+  }
+  return {
+    name: "Pattern location verification",
+    passed: false,
+    error: `Pattern locations not found: ${missing.join(", ")}`,
+    durationMs: Date.now() - start
+  };
+}
+async function verifyFileCount(analysis2, projectPath) {
+  const start = Date.now();
+  try {
+    const actualCount = await countProjectFiles(projectPath);
+    const declared = analysis2.fileCount;
+    const tolerance = 0.1;
+    const diff = Math.abs(actualCount - declared);
+    const allowedDiff = declared * tolerance;
+    if (diff <= allowedDiff) {
+      return {
+        name: "File count verification",
+        passed: true,
+        output: `File count accurate (declared: ${declared}, actual: ${actualCount})`,
+        durationMs: Date.now() - start
+      };
+    }
+    return {
+      name: "File count verification",
+      passed: false,
+      error: `File count mismatch: declared ${declared}, actual ${actualCount} (diff: ${diff})`,
+      durationMs: Date.now() - start
+    };
+  } catch (error) {
+    return {
+      name: "File count verification",
+      passed: false,
+      error: `Failed to count files: ${error instanceof Error ? error.message : "unknown error"}`,
+      durationMs: Date.now() - start
+    };
+  }
+}
+async function verifyAntiPatternFiles(analysis2, projectPath) {
+  const start = Date.now();
+  if (analysis2.antiPatterns.length === 0) {
+    return {
+      name: "Anti-pattern file verification",
+      passed: true,
+      output: "No anti-patterns declared (skipped)",
+      durationMs: Date.now() - start
+    };
+  }
+  const missing = [];
+  const verified = [];
+  for (const antiPattern of analysis2.antiPatterns) {
+    const filePath = path24.join(projectPath, antiPattern.file);
+    try {
+      await fs26.access(filePath);
+      verified.push(antiPattern.file);
+    } catch {
+      missing.push(`${antiPattern.issue} (${antiPattern.file})`);
+    }
+  }
+  if (missing.length === 0) {
+    return {
+      name: "Anti-pattern file verification",
+      passed: true,
+      output: `${verified.length} anti-pattern file(s) verified`,
+      durationMs: Date.now() - start
+    };
+  }
+  return {
+    name: "Anti-pattern file verification",
+    passed: false,
+    error: `Anti-pattern files not found: ${missing.join(", ")}`,
+    durationMs: Date.now() - start
+  };
+}
+async function semanticVerify(analysis2, projectPath) {
+  const totalStart = Date.now();
+  const checks = await Promise.all([
+    verifyFrameworks(analysis2, projectPath),
+    verifyLanguages(analysis2, projectPath),
+    verifyPatternLocations(analysis2, projectPath),
+    verifyFileCount(analysis2, projectPath),
+    verifyAntiPatternFiles(analysis2, projectPath)
+  ]);
+  const failedCount = checks.filter((c) => !c.passed).length;
+  const passedCount = checks.filter((c) => c.passed).length;
+  return {
+    passed: failedCount === 0,
+    checks,
+    totalMs: Date.now() - totalStart,
+    failedCount,
+    passedCount
+  };
+}
+async function getProjectExtensions(projectPath) {
+  const extensions = /* @__PURE__ */ new Set();
+  const ignorePatterns = [/node_modules/, /\.git/, /dist/, /build/, /\.next/, /\.turbo/, /coverage/];
+  async function scanDir(dir) {
+    try {
+      const entries = await fs26.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path24.join(dir, entry.name);
+        const relativePath = path24.relative(projectPath, fullPath);
+        if (ignorePatterns.some((pattern) => pattern.test(relativePath))) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          await scanDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path24.extname(entry.name);
+          if (ext) {
+            extensions.add(ext);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  __name(scanDir, "scanDir");
+  await scanDir(projectPath);
+  return Array.from(extensions);
+}
+async function countProjectFiles(projectPath) {
+  let count = 0;
+  const ignorePatterns = [/node_modules/, /\.git/, /dist/, /build/, /\.next/, /\.turbo/, /coverage/];
+  async function scanDir(dir) {
+    try {
+      const entries = await fs26.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path24.join(dir, entry.name);
+        const relativePath = path24.relative(projectPath, fullPath);
+        if (ignorePatterns.some((pattern) => pattern.test(relativePath))) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          await scanDir(fullPath);
+        } else if (entry.isFile()) {
+          count++;
+        }
+      }
+    } catch {
+    }
+  }
+  __name(scanDir, "scanDir");
+  await scanDir(projectPath);
+  return count;
+}
+var AnalysisStatusSchema, CodePatternSchema, AntiPatternSchema, AnalysisItemSchema, DEFAULT_ANALYSIS, LANGUAGE_EXTENSIONS;
 var init_analysis = __esm({
   "core/schemas/analysis.ts"() {
     "use strict";
+    init_fs();
     init_model();
     AnalysisStatusSchema = z4.enum(["draft", "verified", "sealed"]);
     CodePatternSchema = z4.object({
@@ -9663,6 +9953,31 @@ var init_analysis = __esm({
       analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: "draft"
     };
+    LANGUAGE_EXTENSIONS = {
+      TypeScript: [".ts", ".tsx", ".mts", ".cts"],
+      JavaScript: [".js", ".jsx", ".mjs", ".cjs"],
+      Python: [".py", ".pyw"],
+      Java: [".java"],
+      Go: [".go"],
+      Rust: [".rs"],
+      Ruby: [".rb"],
+      PHP: [".php"],
+      Swift: [".swift"],
+      Kotlin: [".kt", ".kts"],
+      "C++": [".cpp", ".cc", ".cxx", ".hpp", ".h"],
+      C: [".c", ".h"],
+      "C#": [".cs"],
+      Elixir: [".ex", ".exs"],
+      Scala: [".scala"]
+    };
+    __name(verifyFrameworks, "verifyFrameworks");
+    __name(verifyLanguages, "verifyLanguages");
+    __name(verifyPatternLocations, "verifyPatternLocations");
+    __name(verifyFileCount, "verifyFileCount");
+    __name(verifyAntiPatternFiles, "verifyAntiPatternFiles");
+    __name(semanticVerify, "semanticVerify");
+    __name(getProjectExtensions, "getProjectExtensions");
+    __name(countProjectFiles, "countProjectFiles");
   }
 });
 
@@ -10960,8 +11275,8 @@ var init_memory = __esm({
 });
 
 // core/agentic/memory-system.ts
-import fs26 from "node:fs/promises";
-import path24 from "node:path";
+import fs27 from "node:fs/promises";
+import path25 from "node:path";
 function resolveCanonicalDomains(domain) {
   if (KNOWN_DOMAINS.includes(domain)) {
     return [domain];
@@ -11130,12 +11445,12 @@ var init_memory_system = __esm({
        *   (e.g., `~/.prjct-cli/projects/{id}/memory/patterns.json`)
        */
       getPath(projectId) {
-        const basePath = path24.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
+        const basePath = path25.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
         const subdir = this.getSubdirectory();
         if (subdir) {
-          return path24.join(basePath, subdir, this.getFilename());
+          return path25.join(basePath, subdir, this.getFilename());
         }
-        return path24.join(basePath, this.getFilename());
+        return path25.join(basePath, this.getFilename());
       }
       /**
        * Load data from disk with project-scoped caching.
@@ -11159,7 +11474,7 @@ var init_memory_system = __esm({
         }
         const filePath = this.getPath(projectId);
         try {
-          const content = await fs26.readFile(filePath, "utf-8");
+          const content = await fs27.readFile(filePath, "utf-8");
           this._data = JSON.parse(content);
           this.afterLoad(this._data);
         } catch (error) {
@@ -11195,8 +11510,8 @@ var init_memory_system = __esm({
       async save(projectId) {
         if (!this._data) return;
         const filePath = this.getPath(projectId);
-        await fs26.mkdir(path24.dirname(filePath), { recursive: true });
-        await fs26.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
+        await fs27.mkdir(path25.dirname(filePath), { recursive: true });
+        await fs27.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
       }
       /**
        * Access the cached data without triggering a disk read.
@@ -11285,7 +11600,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 path24.join(
+        return path25.join(
           path_manager_default.getGlobalProjectPath(projectId),
           "memory",
           "sessions",
@@ -11295,7 +11610,7 @@ var init_memory_system = __esm({
       }
       async appendHistory(projectId, entry) {
         const sessionPath = this._getSessionPath(projectId);
-        await ensureDir(path24.dirname(sessionPath));
+        await ensureDir(path25.dirname(sessionPath));
         const logEntry = {
           ts: getTimestamp(),
           ...entry,
@@ -11473,8 +11788,8 @@ var init_memory_system = __esm({
         };
       }
       _getArchivePath(projectId) {
-        const basePath = path24.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
-        return path24.join(basePath, "patterns-archive.json");
+        const basePath = path25.join(path_manager_default.getGlobalProjectPath(projectId), "memory");
+        return path25.join(basePath, "patterns-archive.json");
       }
       async archiveStaleDecisions(projectId) {
         const patterns = await this.load(projectId);
@@ -11491,7 +11806,7 @@ var init_memory_system = __esm({
         const archivePath = this._getArchivePath(projectId);
         let archive = {};
         try {
-          const content = await fs26.readFile(archivePath, "utf-8");
+          const content = await fs27.readFile(archivePath, "utf-8");
           archive = JSON.parse(content);
         } catch (error) {
           if (!isNotFoundError(error)) throw error;
@@ -11500,8 +11815,8 @@ var init_memory_system = __esm({
           archive[key] = patterns.decisions[key];
           delete patterns.decisions[key];
         }
-        await fs26.mkdir(path24.dirname(archivePath), { recursive: true });
-        await fs26.writeFile(archivePath, JSON.stringify(archive, null, 2), "utf-8");
+        await fs27.mkdir(path25.dirname(archivePath), { recursive: true });
+        await fs27.writeFile(archivePath, JSON.stringify(archive, null, 2), "utf-8");
         await this.save(projectId);
         return staleKeys.length;
       }
@@ -12349,7 +12664,7 @@ var init_velocity2 = __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"() {
@@ -12368,13 +12683,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.
@@ -12385,7 +12700,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;
       }
@@ -12721,6 +13036,36 @@ var init_analysis_storage = __esm({
           message: `Signature mismatch. Expected ${expected}, got ${data.sealed.signature}. Analysis may have been modified.`
         };
       }
+      /**
+       * Perform semantic verification on analysis results (PRJ-270).
+       * Validates that analysis data matches actual project state:
+       * - Frameworks exist in package.json
+       * - Languages match file extensions
+       * - Pattern locations reference real files
+       * - File count is accurate
+       * - Anti-pattern files exist
+       */
+      async semanticVerify(projectId, projectPath) {
+        const data = await this.read(projectId);
+        const analysis2 = data.sealed ?? data.draft;
+        if (!analysis2) {
+          return {
+            passed: false,
+            checks: [
+              {
+                name: "Analysis availability",
+                passed: false,
+                error: "No analysis available. Run `p. sync` to generate.",
+                durationMs: 0
+              }
+            ],
+            totalMs: 0,
+            failedCount: 1,
+            passedCount: 0
+          };
+        }
+        return await semanticVerify(analysis2, projectPath);
+      }
       // ===========================================================================
       // Private Helpers
       // ===========================================================================
@@ -13138,8 +13483,8 @@ var init_ideas_storage = __esm({
 
 // core/storage/index-storage.ts
 import crypto4 from "node:crypto";
-import fs27 from "node:fs/promises";
-import path26 from "node:path";
+import fs28 from "node:fs/promises";
+import path27 from "node:path";
 function getDefaultChecksums() {
   return {
     version: INDEX_VERSION,
@@ -13165,14 +13510,14 @@ var init_index_storage = __esm({
        * Get the index directory path for a project
        */
       getIndexPath(projectId) {
-        return path26.join(path_manager_default.getGlobalProjectPath(projectId), "index");
+        return path27.join(path_manager_default.getGlobalProjectPath(projectId), "index");
       }
       /**
        * Ensure index directory exists
        */
       async ensureIndexDir(projectId) {
         const indexPath = this.getIndexPath(projectId);
-        await fs27.mkdir(indexPath, { recursive: true });
+        await fs28.mkdir(indexPath, { recursive: true });
         return indexPath;
       }
       // ==========================================================================
@@ -13232,7 +13577,7 @@ var init_index_storage = __esm({
        */
       async calculateChecksum(filePath) {
         try {
-          const content = await fs27.readFile(filePath);
+          const content = await fs28.readFile(filePath);
           return crypto4.createHash("md5").update(content).digest("hex");
         } catch {
           return "";
@@ -13301,8 +13646,8 @@ var init_index_storage = __esm({
         }
         const indexPath = this.getIndexPath(projectId);
         try {
-          const files = await fs27.readdir(indexPath);
-          await Promise.all(files.map((file) => fs27.unlink(path26.join(indexPath, file))));
+          const files = await fs28.readdir(indexPath);
+          await Promise.all(files.map((file) => fs28.unlink(path27.join(indexPath, file))));
         } catch (error) {
           if (!isNotFoundError(error)) {
             throw error;
@@ -13427,8 +13772,8 @@ var init_index_storage = __esm({
 });
 
 // core/storage/migrate-json.ts
-import fs28 from "node:fs/promises";
-import path27 from "node:path";
+import fs29 from "node:fs/promises";
+import path28 from "node:path";
 async function migrateJsonToSqlite(projectId) {
   const start = Date.now();
   const result = {
@@ -13446,13 +13791,13 @@ async function migrateJsonToSqlite(projectId) {
       return result;
     }
     const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-    const storagePath = path27.join(globalPath, "storage");
-    const indexPath = path27.join(globalPath, "index");
-    const memoryPath = path27.join(globalPath, "memory");
+    const storagePath = path28.join(globalPath, "storage");
+    const indexPath = path28.join(globalPath, "index");
+    const memoryPath = path28.join(globalPath, "memory");
     result.backupDir = await createBackup2(storagePath, indexPath, memoryPath);
     prjctDb.getDb(projectId);
     for (const { filename, key } of STORAGE_FILES) {
-      const filePath = path27.join(storagePath, filename);
+      const filePath = path28.join(storagePath, filename);
       const data = await readJsonSafe(filePath);
       if (data === null) {
         result.skippedFiles.push(filename);
@@ -13467,7 +13812,7 @@ async function migrateJsonToSqlite(projectId) {
       }
     }
     for (const { filename, key } of INDEX_FILES) {
-      const filePath = path27.join(indexPath, filename);
+      const filePath = path28.join(indexPath, filename);
       const data = await readJsonSafe(filePath);
       if (data === null) {
         result.skippedFiles.push(`index/${filename}`);
@@ -13504,28 +13849,28 @@ async function migrateJsonToSqlite(projectId) {
   }
 }
 async function createBackup2(storagePath, indexPath, memoryPath) {
-  const backupDir = path27.join(storagePath, "backup");
-  await fs28.mkdir(backupDir, { recursive: true });
-  await fs28.mkdir(path27.join(backupDir, "index"), { recursive: true });
-  await fs28.mkdir(path27.join(backupDir, "memory"), { recursive: true });
+  const backupDir = path28.join(storagePath, "backup");
+  await fs29.mkdir(backupDir, { recursive: true });
+  await fs29.mkdir(path28.join(backupDir, "index"), { recursive: true });
+  await fs29.mkdir(path28.join(backupDir, "memory"), { recursive: true });
   await copyFiles(
     storagePath,
     backupDir,
     (name) => name.endsWith(".json") || name.endsWith(".jsonl")
   );
-  await copyFiles(indexPath, path27.join(backupDir, "index"));
-  await copyFiles(memoryPath, path27.join(backupDir, "memory"));
+  await copyFiles(indexPath, path28.join(backupDir, "index"));
+  await copyFiles(memoryPath, path28.join(backupDir, "memory"));
   return backupDir;
 }
 async function copyFiles(srcDir, destDir, filter) {
   try {
-    const entries = await fs28.readdir(srcDir, { withFileTypes: true });
+    const entries = await fs29.readdir(srcDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (filter && !filter(entry.name)) continue;
-      const src = path27.join(srcDir, entry.name);
-      const dest = path27.join(destDir, entry.name);
-      await fs28.copyFile(src, dest);
+      const src = path28.join(srcDir, entry.name);
+      const dest = path28.join(destDir, entry.name);
+      await fs29.copyFile(src, dest);
     }
   } catch (err) {
     if (!isNotFoundError(err)) throw err;
@@ -13755,7 +14100,7 @@ function populateCategoriesIndex(projectId, cache2) {
   }
 }
 async function migrateChecksums(projectId, indexPath, result) {
-  const filePath = path27.join(indexPath, "checksums.json");
+  const filePath = path28.join(indexPath, "checksums.json");
   const data = await readJsonSafe(filePath);
   if (data === null) {
     result.skippedFiles.push("index/checksums.json");
@@ -13777,7 +14122,7 @@ async function migrateChecksums(projectId, indexPath, result) {
   }
 }
 async function migrateFileScores(projectId, indexPath, result) {
-  const filePath = path27.join(indexPath, "file-scores.json");
+  const filePath = path28.join(indexPath, "file-scores.json");
   const data = await readJsonSafe(filePath);
   if (data === null) {
     result.skippedFiles.push("index/file-scores.json");
@@ -13812,9 +14157,9 @@ async function migrateFileScores(projectId, indexPath, result) {
   }
 }
 async function migrateEventsJsonl(projectId, memoryPath, result) {
-  const filePath = path27.join(memoryPath, "events.jsonl");
+  const filePath = path28.join(memoryPath, "events.jsonl");
   try {
-    const content = await fs28.readFile(filePath, "utf-8");
+    const content = await fs29.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     if (lines.length === 0) {
       result.skippedFiles.push("memory/events.jsonl");
@@ -13846,9 +14191,9 @@ async function migrateEventsJsonl(projectId, memoryPath, result) {
   }
 }
 async function migrateLearningsJsonl(projectId, memoryPath, result) {
-  const filePath = path27.join(memoryPath, "learnings.jsonl");
+  const filePath = path28.join(memoryPath, "learnings.jsonl");
   try {
-    const content = await fs28.readFile(filePath, "utf-8");
+    const content = await fs29.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     if (lines.length === 0) {
       result.skippedFiles.push("memory/learnings.jsonl");
@@ -13882,7 +14227,7 @@ async function migrateLearningsJsonl(projectId, memoryPath, result) {
 async function cleanupJsonFiles(storagePath, indexPath, memoryPath, result) {
   const deleteFile2 = /* @__PURE__ */ __name(async (filePath, label) => {
     try {
-      await fs28.unlink(filePath);
+      await fs29.unlink(filePath);
     } catch (err) {
       if (!isNotFoundError(err)) {
         result.errors.push({ file: label, error: `cleanup: ${String(err)}` });
@@ -13890,7 +14235,7 @@ async function cleanupJsonFiles(storagePath, indexPath, memoryPath, result) {
     }
   }, "deleteFile");
   for (const { filename } of STORAGE_FILES) {
-    await deleteFile2(path27.join(storagePath, filename), `cleanup:${filename}`);
+    await deleteFile2(path28.join(storagePath, filename), `cleanup:${filename}`);
   }
   const indexFiles = [
     "project-index.json",
@@ -13900,14 +14245,14 @@ async function cleanupJsonFiles(storagePath, indexPath, memoryPath, result) {
     "file-scores.json"
   ];
   for (const filename of indexFiles) {
-    await deleteFile2(path27.join(indexPath, filename), `cleanup:index/${filename}`);
+    await deleteFile2(path28.join(indexPath, filename), `cleanup:index/${filename}`);
   }
-  await deleteFile2(path27.join(memoryPath, "events.jsonl"), "cleanup:memory/events.jsonl");
-  await deleteFile2(path27.join(memoryPath, "learnings.jsonl"), "cleanup:memory/learnings.jsonl");
+  await deleteFile2(path28.join(memoryPath, "events.jsonl"), "cleanup:memory/events.jsonl");
+  await deleteFile2(path28.join(memoryPath, "learnings.jsonl"), "cleanup:memory/learnings.jsonl");
 }
 async function readJsonSafe(filePath) {
   try {
-    const content = await fs28.readFile(filePath, "utf-8");
+    const content = await fs29.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     if (isNotFoundError(err) || err instanceof SyntaxError) {
@@ -15469,9 +15814,9 @@ ${errors.join("\n")}`);
 });
 
 // core/storage/storage.ts
-import fs29 from "node:fs/promises";
+import fs30 from "node:fs/promises";
 import os8 from "node:os";
-import path28 from "node:path";
+import path29 from "node:path";
 function getStorage(projectId) {
   return new FileStorage(projectId);
 }
@@ -15489,7 +15834,7 @@ var init_storage = __esm({
       basePath;
       constructor(projectId) {
         this.projectId = projectId;
-        this.basePath = path28.join(os8.homedir(), ".prjct-cli/projects", projectId, "data");
+        this.basePath = path29.join(os8.homedir(), ".prjct-cli/projects", projectId, "data");
       }
       /**
        * Convert path array to file path
@@ -15498,17 +15843,17 @@ var init_storage = __esm({
        */
       pathToFile(pathArray) {
         if (pathArray.length === 1) {
-          return path28.join(this.basePath, `${pathArray[0]}.json`);
+          return path29.join(this.basePath, `${pathArray[0]}.json`);
         }
         const dir = `${pathArray[0]}s`;
         const rest = pathArray.slice(1);
         const filename = `${rest.join("/")}.json`;
-        return path28.join(this.basePath, dir, filename);
+        return path29.join(this.basePath, dir, filename);
       }
       async write(pathArray, data) {
         const filePath = this.pathToFile(pathArray);
-        await fs29.mkdir(path28.dirname(filePath), { recursive: true });
-        await fs29.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs30.mkdir(path29.dirname(filePath), { recursive: true });
+        await fs30.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
         eventBus.publish({
           type: inferEventType(pathArray, "write"),
           path: pathArray,
@@ -15523,7 +15868,7 @@ var init_storage = __esm({
       async read(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          const content = await fs29.readFile(filePath, "utf-8");
+          const content = await fs30.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -15533,9 +15878,9 @@ var init_storage = __esm({
         }
       }
       async list(prefix) {
-        const dir = path28.join(this.basePath, `${prefix[0]}s`);
+        const dir = path29.join(this.basePath, `${prefix[0]}s`);
         try {
-          const files = await fs29.readdir(dir);
+          const files = await fs30.readdir(dir);
           return files.filter((f) => f.endsWith(".json") && f !== "index.json").map((f) => [...prefix, f.replace(".json", "")]);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -15547,7 +15892,7 @@ var init_storage = __esm({
       async delete(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs29.unlink(filePath);
+          await fs30.unlink(filePath);
           eventBus.publish({
             type: inferEventType(pathArray, "delete"),
             path: pathArray,
@@ -15567,7 +15912,7 @@ var init_storage = __esm({
       async exists(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs29.access(filePath);
+          await fs30.access(filePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -15580,10 +15925,10 @@ var init_storage = __esm({
        * Update collection index
        */
       async updateIndex(collection, id, action) {
-        const indexPath = path28.join(this.basePath, `${collection}s`, "index.json");
+        const indexPath = path29.join(this.basePath, `${collection}s`, "index.json");
         let index = { ids: [], updatedAt: "" };
         try {
-          const content = await fs29.readFile(indexPath, "utf-8");
+          const content = await fs30.readFile(indexPath, "utf-8");
           index = JSON.parse(content);
         } catch (error) {
           if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
@@ -15596,8 +15941,8 @@ var init_storage = __esm({
           index.ids = index.ids.filter((i) => i !== id);
         }
         index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await fs29.mkdir(path28.dirname(indexPath), { recursive: true });
-        await fs29.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+        await fs30.mkdir(path29.dirname(indexPath), { recursive: true });
+        await fs30.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
       }
     };
     __name(getStorage, "getStorage");
@@ -15735,15 +16080,15 @@ var init_storage2 = __esm({
 
 // core/agentic/domain-classifier.ts
 import { createHash as createHash2 } from "node:crypto";
-import fs30 from "node:fs/promises";
-import path29 from "node:path";
+import fs31 from "node:fs/promises";
+import path30 from "node:path";
 function hashDescription(description) {
   return createHash2("sha256").update(description.toLowerCase().trim()).digest("hex").slice(0, 16);
 }
 async function loadCache(globalPath) {
   try {
-    const cachePath = path29.join(globalPath, "storage", "classification-cache.json");
-    const content = await fs30.readFile(cachePath, "utf-8");
+    const cachePath = path30.join(globalPath, "storage", "classification-cache.json");
+    const content = await fs31.readFile(cachePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (isNotFoundError(error)) return DEFAULT_CLASSIFICATION_CACHE;
@@ -15753,8 +16098,8 @@ async function loadCache(globalPath) {
 }
 async function saveCache(globalPath, cache2) {
   try {
-    const cachePath = path29.join(globalPath, "storage", "classification-cache.json");
-    await fs30.writeFile(cachePath, JSON.stringify(cache2, null, 2));
+    const cachePath = path30.join(globalPath, "storage", "classification-cache.json");
+    await fs31.writeFile(cachePath, JSON.stringify(cache2, null, 2));
   } catch (error) {
     console.warn("[classifier] Failed to save cache:", getErrorMessage2(error));
   }
@@ -16126,8 +16471,8 @@ var init_domain_classifier = __esm({
 });
 
 // core/agentic/template-loader.ts
-import fs31 from "node:fs/promises";
-import path30 from "node:path";
+import fs32 from "node:fs/promises";
+import path31 from "node:path";
 function updateLruOrder(key) {
   const index = cacheOrder.indexOf(key);
   if (index > -1) cacheOrder.splice(index, 1);
@@ -16165,9 +16510,9 @@ async function load(commandName) {
     updateLruOrder(commandName);
     return cache.get(commandName);
   }
-  const templatePath = path30.join(TEMPLATES_DIR, `${commandName}.md`);
+  const templatePath = path31.join(TEMPLATES_DIR, `${commandName}.md`);
   try {
-    const rawContent = await fs31.readFile(templatePath, "utf-8");
+    const rawContent = await fs32.readFile(templatePath, "utf-8");
     const parsed = parseFrontmatter(rawContent);
     evictLru();
     cache.set(commandName, parsed);
@@ -16190,7 +16535,7 @@ var init_template_loader = __esm({
   "core/agentic/template-loader.ts"() {
     "use strict";
     init_errors();
-    TEMPLATES_DIR = path30.join(__dirname, "..", "..", "templates", "commands");
+    TEMPLATES_DIR = path31.join(__dirname, "..", "..", "templates", "commands");
     MAX_CACHE_SIZE = 50;
     cache = /* @__PURE__ */ new Map();
     cacheOrder = [];
@@ -16207,9 +16552,9 @@ var init_template_loader = __esm({
 
 // core/agentic/orchestrator-executor.ts
 import { exec as execCallback5 } from "node:child_process";
-import fs32 from "node:fs/promises";
+import fs33 from "node:fs/promises";
 import os9 from "node:os";
-import path31 from "node:path";
+import path32 from "node:path";
 import { promisify as promisify7 } from "node:util";
 var execAsync3, DOMAIN_DEPENDENCY_ORDER, OrchestratorExecutor, orchestratorExecutor, orchestrator_executor_default;
 var init_orchestrator_executor = __esm({
@@ -16397,8 +16742,8 @@ var init_orchestrator_executor = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path31.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs32.readFile(analysisPath, "utf-8");
+          const analysisPath = path32.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs33.readFile(analysisPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error)) return null;
@@ -16423,8 +16768,8 @@ var init_orchestrator_executor = __esm({
           hasDocker: false
         };
         try {
-          const statePath = path31.join(globalPath, "storage", "state.json");
-          const stateContent = await fs32.readFile(statePath, "utf-8");
+          const statePath = path32.join(globalPath, "storage", "state.json");
+          const stateContent = await fs33.readFile(statePath, "utf-8");
           const state = JSON.parse(stateContent);
           if (state.domains) {
             projectDomains = state.domains;
@@ -16458,8 +16803,8 @@ var init_orchestrator_executor = __esm({
        */
       async getAvailableAgentNames(globalPath) {
         try {
-          const agentsDir = path31.join(globalPath, "agents");
-          const files = await fs32.readdir(agentsDir);
+          const agentsDir = path32.join(globalPath, "agents");
+          const files = await fs33.readdir(agentsDir);
           return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
         } catch {
           return [];
@@ -16475,13 +16820,13 @@ var init_orchestrator_executor = __esm({
        */
       async loadAgents(domains, projectId) {
         const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-        const agentsDir = path31.join(globalPath, "agents");
+        const agentsDir = path32.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 = path31.join(agentsDir, fileName);
+            const filePath = path32.join(agentsDir, fileName);
             try {
-              const content = await fs32.readFile(filePath, "utf-8");
+              const content = await fs33.readFile(filePath, "utf-8");
               const { frontmatter, body } = this.parseAgentFile(content);
               return {
                 name: fileName.replace(".md", ""),
@@ -16522,7 +16867,7 @@ var init_orchestrator_executor = __esm({
        * Uses parallel file reads for performance (PRJ-110).
        */
       async loadSkills(agents) {
-        const skillsDir = path31.join(os9.homedir(), ".claude", "skills");
+        const skillsDir = path32.join(os9.homedir(), ".claude", "skills");
         const skillToAgents = /* @__PURE__ */ new Map();
         for (const agent of agents) {
           for (const skillName of agent.skills) {
@@ -16533,14 +16878,14 @@ var init_orchestrator_executor = __esm({
         }
         const skillPromises = Array.from(skillToAgents.keys()).map(
           async (skillName) => {
-            const flatPath = path31.join(skillsDir, `${skillName}.md`);
-            const subdirPath = path31.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path32.join(skillsDir, `${skillName}.md`);
+            const subdirPath = path32.join(skillsDir, skillName, "SKILL.md");
             try {
-              const content = await fs32.readFile(subdirPath, "utf-8");
+              const content = await fs33.readFile(subdirPath, "utf-8");
               return { name: skillName, content, filePath: subdirPath };
             } catch {
               try {
-                const content = await fs32.readFile(flatPath, "utf-8");
+                const content = await fs33.readFile(flatPath, "utf-8");
                 return { name: skillName, content, filePath: flatPath };
               } catch {
                 const agentNames = skillToAgents.get(skillName) || [];
@@ -17568,11 +17913,11 @@ var init_command_classifier = __esm({
 });
 
 // core/agentic/command-context.ts
-import fs33 from "node:fs/promises";
-import path32 from "node:path";
+import fs34 from "node:fs/promises";
+import path33 from "node:path";
 async function loadCommandContextConfig() {
   if (cachedConfig) return cachedConfig;
-  const raw = await fs33.readFile(CONFIG_PATH, "utf-8");
+  const raw = await fs34.readFile(CONFIG_PATH, "utf-8");
   const parsed = JSON.parse(raw);
   cachedConfig = CommandContextConfigSchema.parse(parsed);
   return cachedConfig;
@@ -17594,10 +17939,10 @@ function trackClassification(commandName, entry) {
   return false;
 }
 async function persistClassification(commandName, entry) {
-  const raw = await fs33.readFile(CONFIG_PATH, "utf-8");
+  const raw = await fs34.readFile(CONFIG_PATH, "utf-8");
   const config = JSON.parse(raw);
   config.commands[commandName] = entry;
-  await fs33.writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+  await fs34.writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
   cachedConfig = null;
 }
@@ -17631,7 +17976,7 @@ var init_command_context2 = __esm({
     init_command_context();
     init_version();
     init_command_classifier();
-    CONFIG_PATH = path32.join(PACKAGE_ROOT, "core/config/command-context.config.json");
+    CONFIG_PATH = path33.join(PACKAGE_ROOT, "core/config/command-context.config.json");
     cachedConfig = null;
     __name(loadCommandContextConfig, "loadCommandContextConfig");
     classificationCache = /* @__PURE__ */ new Map();
@@ -17814,8 +18159,8 @@ var init_injection_validator = __esm({
 });
 
 // core/agentic/prompt-builder.ts
-import fs34 from "node:fs/promises";
-import path33 from "node:path";
+import fs35 from "node:fs/promises";
+import path34 from "node:path";
 var PromptBuilder, promptBuilder, prompt_builder_default;
 var init_prompt_builder = __esm({
   "core/agentic/prompt-builder.ts"() {
@@ -17860,7 +18205,7 @@ var init_prompt_builder = __esm({
         }
         try {
           if (await fileExists(templatePath)) {
-            const content = await fs34.readFile(templatePath, "utf-8");
+            const content = await fs35.readFile(templatePath, "utf-8");
             this._templateCache.set(templatePath, { content, loadedAt: now });
             return content;
           }
@@ -17924,7 +18269,7 @@ var init_prompt_builder = __esm({
        * These modules extend the base global CLAUDE.md for complex operations
        */
       async loadModule(moduleName) {
-        const modulePath = path33.join(PACKAGE_ROOT, "templates/global/modules", moduleName);
+        const modulePath = path34.join(PACKAGE_ROOT, "templates/global/modules", moduleName);
         return this.getTemplate(modulePath);
       }
       /**
@@ -17947,14 +18292,14 @@ var init_prompt_builder = __esm({
         if (this._checklistsCache && now - this._checklistsCacheTime < this.TEMPLATE_CACHE_TTL_MS) {
           return this._checklistsCache;
         }
-        const checklistsDir = path33.join(__dirname, "..", "..", "templates", "checklists");
+        const checklistsDir = path34.join(__dirname, "..", "..", "templates", "checklists");
         const checklists = {};
         try {
           if (await fileExists(checklistsDir)) {
-            const files = (await fs34.readdir(checklistsDir)).filter((f) => f.endsWith(".md"));
+            const files = (await fs35.readdir(checklistsDir)).filter((f) => f.endsWith(".md"));
             for (const file of files) {
               const name = file.replace(".md", "");
-              const templatePath = path33.join(checklistsDir, file);
+              const templatePath = path34.join(checklistsDir, file);
               const content = await this.getTemplate(templatePath);
               if (content) {
                 checklists[name] = content;
@@ -18074,7 +18419,7 @@ var init_prompt_builder = __esm({
         if (this._checklistRoutingCache && now - this._checklistRoutingCacheTime < this.TEMPLATE_CACHE_TTL_MS) {
           return this._checklistRoutingCache;
         }
-        const routingPath = path33.join(
+        const routingPath = path34.join(
           __dirname,
           "..",
           "..",
@@ -18161,7 +18506,7 @@ Apply specialized expertise. Read agent file for details if needed.
         }
         const projectPath = context2.projectPath;
         if (projectPath) {
-          const projectName = orchestratorContext?.project?.id ? path33.basename(projectPath) : path33.basename(projectPath);
+          const projectName = orchestratorContext?.project?.id ? path34.basename(projectPath) : path34.basename(projectPath);
           const envBlock = buildEnvironmentBlock({
             projectName,
             projectPath,
@@ -18657,8 +19002,8 @@ EXECUTE: Follow flow. Use tools. Decide.
 });
 
 // core/agentic/template-executor.ts
-import fs35 from "node:fs/promises";
-import path34 from "node:path";
+import fs36 from "node:fs/promises";
+import path35 from "node:path";
 var ORCHESTRATED_COMMANDS, SIMPLE_COMMANDS, TemplateExecutor, templateExecutor, template_executor_default;
 var init_template_executor = __esm({
   "core/agentic/template-executor.ts"() {
@@ -18676,7 +19021,7 @@ var init_template_executor = __esm({
        * Get npm root for templates path
        */
       async getNpmRoot() {
-        const moduleDir = path34.dirname(__require.resolve("prjct-cli/package.json"));
+        const moduleDir = path35.dirname(__require.resolve("prjct-cli/package.json"));
         return moduleDir;
       }
       /**
@@ -18697,9 +19042,9 @@ var init_template_executor = __esm({
         let templatesDir;
         try {
           const npmRoot = await this.getNpmRoot();
-          templatesDir = path34.join(npmRoot, "templates");
+          templatesDir = path35.join(npmRoot, "templates");
         } catch {
-          templatesDir = path34.join(__dirname, "..", "..", "templates");
+          templatesDir = path35.join(__dirname, "..", "..", "templates");
         }
         return {
           projectPath,
@@ -18710,14 +19055,14 @@ var init_template_executor = __esm({
           agentName: activeProvider.displayName,
           agentSettingsPath: await path_manager_default.getAgentSettingsPath(),
           paths: {
-            orchestrator: path34.join(templatesDir, "agentic", "orchestrator.md"),
-            agentRouting: path34.join(templatesDir, "agentic", "agent-routing.md"),
-            taskFragmentation: path34.join(templatesDir, "agentic", "task-fragmentation.md"),
-            commandTemplate: path34.join(templatesDir, "commands", `${command}.md`),
-            repoAnalysis: path34.join(globalPath, "analysis", "repo-analysis.json"),
-            agentsDir: path34.join(globalPath, "agents"),
+            orchestrator: path35.join(templatesDir, "agentic", "orchestrator.md"),
+            agentRouting: path35.join(templatesDir, "agentic", "agent-routing.md"),
+            taskFragmentation: path35.join(templatesDir, "agentic", "task-fragmentation.md"),
+            commandTemplate: path35.join(templatesDir, "commands", `${command}.md`),
+            repoAnalysis: path35.join(globalPath, "analysis", "repo-analysis.json"),
+            agentsDir: path35.join(globalPath, "agents"),
             skillsDir: activeProvider.skillsDir,
-            stateJson: path34.join(globalPath, "storage", "state.json")
+            stateJson: path35.join(globalPath, "storage", "state.json")
           }
         };
       }
@@ -18735,8 +19080,8 @@ var init_template_executor = __esm({
       async hasAgents(projectPath) {
         try {
           const projectId = await this.getProjectId(projectPath);
-          const agentsDir = path34.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
-          const files = await fs35.readdir(agentsDir);
+          const agentsDir = path35.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
+          const files = await fs36.readdir(agentsDir);
           return files.some((f) => f.endsWith(".md"));
         } catch (error) {
           if (isNotFoundError(error)) return false;
@@ -18749,8 +19094,8 @@ var init_template_executor = __esm({
       async getAvailableAgents(projectPath) {
         try {
           const projectId = await this.getProjectId(projectPath);
-          const agentsDir = path34.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
-          const files = await fs35.readdir(agentsDir);
+          const agentsDir = path35.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
+          const files = await fs36.readdir(agentsDir);
           return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
         } catch {
           return [];
@@ -18857,14 +19202,220 @@ When fragmenting tasks:
   }
 });
 
+// core/utils/retry.ts
+function isTransientError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  if (err.code && TRANSIENT_ERROR_CODES.has(err.code)) {
+    return true;
+  }
+  if (err.code && PERMANENT_ERROR_CODES.has(err.code)) {
+    return false;
+  }
+  if (err.message) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes("timeout") || msg.includes("timed out")) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPermanentError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  return !!(err.code && PERMANENT_ERROR_CODES.has(err.code));
+}
+function isCircuitOpen(operationId, threshold, timeoutMs) {
+  const state = circuitStates.get(operationId);
+  if (!state) {
+    return false;
+  }
+  if (state.consecutiveFailures >= threshold && state.openedAt) {
+    const elapsed = Date.now() - state.openedAt;
+    if (elapsed >= timeoutMs) {
+      circuitStates.delete(operationId);
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function recordFailure(operationId, threshold) {
+  const state = circuitStates.get(operationId) || {
+    consecutiveFailures: 0,
+    openedAt: null
+  };
+  state.consecutiveFailures++;
+  if (state.consecutiveFailures >= threshold && !state.openedAt) {
+    state.openedAt = Date.now();
+  }
+  circuitStates.set(operationId, state);
+}
+function recordSuccess(operationId) {
+  circuitStates.delete(operationId);
+}
+var TRANSIENT_ERROR_CODES, PERMANENT_ERROR_CODES, circuitStates, RetryPolicy, defaultAgentRetryPolicy, defaultToolRetryPolicy;
+var init_retry = __esm({
+  "core/utils/retry.ts"() {
+    "use strict";
+    TRANSIENT_ERROR_CODES = /* @__PURE__ */ new Set([
+      "EBUSY",
+      // Resource busy
+      "EAGAIN",
+      // Resource temporarily unavailable
+      "ETIMEDOUT",
+      // Operation timed out
+      "ECONNRESET",
+      // Connection reset by peer
+      "ECONNREFUSED",
+      // Connection refused (may be temporary)
+      "ENOTFOUND",
+      // DNS lookup failed (may be temporary)
+      "EAI_AGAIN"
+      // DNS temporary failure
+    ]);
+    PERMANENT_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ENOENT",
+      // No such file or directory
+      "EACCES",
+      // Permission denied
+      "EPERM",
+      // Operation not permitted
+      "EISDIR",
+      // Is a directory
+      "ENOTDIR",
+      // Not a directory
+      "EINVAL"
+      // Invalid argument
+    ]);
+    __name(isTransientError, "isTransientError");
+    __name(isPermanentError, "isPermanentError");
+    circuitStates = /* @__PURE__ */ new Map();
+    __name(isCircuitOpen, "isCircuitOpen");
+    __name(recordFailure, "recordFailure");
+    __name(recordSuccess, "recordSuccess");
+    RetryPolicy = class {
+      static {
+        __name(this, "RetryPolicy");
+      }
+      options;
+      constructor(options = {}) {
+        this.options = {
+          maxAttempts: options.maxAttempts ?? 3,
+          baseDelayMs: options.baseDelayMs ?? 1e3,
+          maxDelayMs: options.maxDelayMs ?? 8e3,
+          circuitBreakerThreshold: options.circuitBreakerThreshold ?? 5,
+          circuitBreakerTimeoutMs: options.circuitBreakerTimeoutMs ?? 6e4
+        };
+      }
+      /**
+       * Execute an operation with retry logic
+       *
+       * @param operation - Async function to execute
+       * @param operationId - Optional ID for circuit breaker tracking
+       * @returns Result of the operation
+       * @throws Error if all attempts fail or circuit is open
+       */
+      async execute(operation, operationId = "default") {
+        if (isCircuitOpen(
+          operationId,
+          this.options.circuitBreakerThreshold,
+          this.options.circuitBreakerTimeoutMs
+        )) {
+          throw new Error(
+            `Circuit breaker is open for operation: ${operationId}. Too many consecutive failures.`
+          );
+        }
+        let lastError;
+        let attempt = 0;
+        while (attempt < this.options.maxAttempts) {
+          try {
+            const result = await operation();
+            recordSuccess(operationId);
+            return result;
+          } catch (error) {
+            lastError = error;
+            attempt++;
+            if (isPermanentError(error)) {
+              recordFailure(operationId, this.options.circuitBreakerThreshold);
+              throw error;
+            }
+            const shouldRetry = isTransientError(error) && attempt < this.options.maxAttempts;
+            if (!shouldRetry) {
+              recordFailure(operationId, this.options.circuitBreakerThreshold);
+              throw error;
+            }
+            const delay = Math.min(
+              this.options.baseDelayMs * 2 ** (attempt - 1),
+              this.options.maxDelayMs
+            );
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        }
+        recordFailure(operationId, this.options.circuitBreakerThreshold);
+        throw lastError;
+      }
+      /**
+       * Check if an error is transient (exposed for testing)
+       */
+      isTransientError(error) {
+        return isTransientError(error);
+      }
+      /**
+       * Check if circuit is open for an operation (exposed for testing)
+       */
+      isCircuitOpen(operationId) {
+        return isCircuitOpen(
+          operationId,
+          this.options.circuitBreakerThreshold,
+          this.options.circuitBreakerTimeoutMs
+        );
+      }
+      /**
+       * Get current circuit state for an operation (exposed for testing)
+       */
+      getCircuitState(operationId) {
+        return circuitStates.get(operationId);
+      }
+      /**
+       * Reset circuit breaker for an operation (exposed for testing)
+       */
+      resetCircuit(operationId) {
+        circuitStates.delete(operationId);
+      }
+      /**
+       * Reset all circuit breakers (exposed for testing)
+       */
+      resetAllCircuits() {
+        circuitStates.clear();
+      }
+    };
+    defaultAgentRetryPolicy = new RetryPolicy({
+      maxAttempts: 3,
+      baseDelayMs: 1e3,
+      maxDelayMs: 8e3
+    });
+    defaultToolRetryPolicy = new RetryPolicy({
+      maxAttempts: 2,
+      baseDelayMs: 500,
+      maxDelayMs: 2e3
+    });
+  }
+});
+
 // core/agentic/tool-registry.ts
 import { exec as exec7 } from "node:child_process";
-import fs36 from "node:fs/promises";
+import fs37 from "node:fs/promises";
 import { promisify as promisify8 } from "node:util";
 var execAsync4, toolRegistry, tool_registry_default;
 var init_tool_registry = __esm({
   "core/agentic/tool-registry.ts"() {
     "use strict";
+    init_retry();
     execAsync4 = promisify8(exec7);
     toolRegistry = {
       tools: /* @__PURE__ */ new Map(),
@@ -18903,16 +19454,34 @@ var init_tool_registry = __esm({
     };
     toolRegistry.register("Read", async (filePath) => {
       try {
-        return await fs36.readFile(filePath, "utf-8");
-      } catch (_error) {
+        return await defaultToolRetryPolicy.execute(
+          async () => await fs37.readFile(filePath, "utf-8"),
+          `read-${filePath}`
+        );
+      } catch (error) {
+        if (isPermanentError(error)) {
+          return null;
+        }
+        if (isTransientError(error)) {
+          return null;
+        }
         return null;
       }
     });
     toolRegistry.register("Write", async (filePath, content) => {
       try {
-        await fs36.writeFile(filePath, content, "utf-8");
+        await defaultToolRetryPolicy.execute(
+          async () => await fs37.writeFile(filePath, content, "utf-8"),
+          `write-${filePath}`
+        );
         return true;
-      } catch (_error) {
+      } catch (error) {
+        if (isPermanentError(error)) {
+          return false;
+        }
+        if (isTransientError(error)) {
+          return false;
+        }
         return false;
       }
     });
@@ -18920,8 +19489,10 @@ var init_tool_registry = __esm({
       "Bash",
       async (command) => {
         try {
-          const { stdout, stderr } = await execAsync4(command);
-          return { stdout, stderr };
+          return await defaultToolRetryPolicy.execute(
+            async () => await execAsync4(command),
+            `bash-${command}`
+          );
         } catch (error) {
           const err = error;
           return {
@@ -18945,23 +19516,23 @@ var init_tool_registry = __esm({
 });
 
 // core/agentic/command-executor.ts
-import fs37 from "node:fs/promises";
+import fs38 from "node:fs/promises";
 import os11 from "node:os";
-import path35 from "node:path";
+import path36 from "node:path";
 async function signalStart(commandName) {
   try {
-    const dir = path35.dirname(RUNNING_FILE);
+    const dir = path36.dirname(RUNNING_FILE);
     if (!await fileExists(dir)) {
-      await fs37.mkdir(dir, { recursive: true });
+      await fs38.mkdir(dir, { recursive: true });
     }
-    await fs37.writeFile(RUNNING_FILE, `/p:${commandName}`);
+    await fs38.writeFile(RUNNING_FILE, `/p:${commandName}`);
   } catch (_error) {
   }
 }
 async function signalEnd() {
   try {
     if (await fileExists(RUNNING_FILE)) {
-      await fs37.unlink(RUNNING_FILE);
+      await fs38.unlink(RUNNING_FILE);
     }
   } catch (_error) {
   }
@@ -18985,7 +19556,7 @@ var init_command_executor = __esm({
     init_template_executor();
     init_template_loader();
     init_tool_registry();
-    RUNNING_FILE = path35.join(os11.homedir(), ".prjct-cli", ".running");
+    RUNNING_FILE = path36.join(os11.homedir(), ".prjct-cli", ".running");
     __name(signalStart, "signalStart");
     __name(signalEnd, "signalEnd");
     CommandExecutor = class {
@@ -19294,10 +19865,10 @@ var init_command_executor = __esm({
 });
 
 // core/infrastructure/update-checker.ts
-import fs38 from "node:fs/promises";
+import fs39 from "node:fs/promises";
 import https from "node:https";
 import os12 from "node:os";
-import path36 from "node:path";
+import path37 from "node:path";
 import chalk8 from "chalk";
 var UpdateChecker, update_checker_default;
 var init_update_checker = __esm({
@@ -19315,8 +19886,8 @@ var init_update_checker = __esm({
       checkInterval;
       constructor() {
         this.packageName = "prjct-cli";
-        this.cacheDir = path36.join(os12.homedir(), ".prjct-cli", "config");
-        this.cacheFile = path36.join(this.cacheDir, "update-cache.json");
+        this.cacheDir = path37.join(os12.homedir(), ".prjct-cli", "config");
+        this.cacheFile = path37.join(this.cacheDir, "update-cache.json");
         this.checkInterval = 24 * 60 * 60 * 1e3;
       }
       /**
@@ -19324,8 +19895,8 @@ var init_update_checker = __esm({
        */
       async getCurrentVersion() {
         try {
-          const packageJsonPath = path36.join(__dirname, "..", "..", "package.json");
-          const packageJson = JSON.parse(await fs38.readFile(packageJsonPath, "utf8"));
+          const packageJsonPath = path37.join(__dirname, "..", "..", "package.json");
+          const packageJson = JSON.parse(await fs39.readFile(packageJsonPath, "utf8"));
           return packageJson.version;
         } catch (error) {
           console.error("Error reading package version:", getErrorMessage2(error));
@@ -19395,7 +19966,7 @@ var init_update_checker = __esm({
       async readCache() {
         try {
           if (await fileExists(this.cacheFile)) {
-            const cache2 = JSON.parse(await fs38.readFile(this.cacheFile, "utf8"));
+            const cache2 = JSON.parse(await fs39.readFile(this.cacheFile, "utf8"));
             return cache2;
           }
         } catch (_error) {
@@ -19408,9 +19979,9 @@ var init_update_checker = __esm({
       async writeCache(data) {
         try {
           if (!await fileExists(this.cacheDir)) {
-            await fs38.mkdir(this.cacheDir, { recursive: true });
+            await fs39.mkdir(this.cacheDir, { recursive: true });
           }
-          await fs38.writeFile(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
+          await fs39.writeFile(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
         } catch (_error) {
         }
       }
@@ -19564,12 +20135,13 @@ var init_agent_generator = __esm({
   "core/services/agent-generator.ts"() {
     "use strict";
     init_preserve_sections();
+    init_retry();
   }
 });
 
 // core/agentic/agent-router.ts
-import fs39 from "node:fs/promises";
-import path37 from "node:path";
+import fs40 from "node:fs/promises";
+import path38 from "node:path";
 var AgentRouter, agent_router_default;
 var init_agent_router = __esm({
   "core/agentic/agent-router.ts"() {
@@ -19598,12 +20170,12 @@ var init_agent_router = __esm({
       async loadAvailableAgents() {
         if (!this.agentsPath) return [];
         try {
-          const files = await fs39.readdir(this.agentsPath);
+          const files = await fs40.readdir(this.agentsPath);
           const agents = [];
           for (const file of files) {
             if (file.endsWith(".md")) {
               const name = file.replace(".md", "");
-              const content = await fs39.readFile(path37.join(this.agentsPath, file), "utf-8");
+              const content = await fs40.readFile(path38.join(this.agentsPath, file), "utf-8");
               agents.push({ name, content });
             }
           }
@@ -19628,8 +20200,8 @@ var init_agent_router = __esm({
       async loadAgent(name) {
         if (!this.agentsPath) return null;
         try {
-          const filePath = path37.join(this.agentsPath, `${name}.md`);
-          const content = await fs39.readFile(filePath, "utf-8");
+          const filePath = path38.join(this.agentsPath, `${name}.md`);
+          const content = await fs40.readFile(filePath, "utf-8");
           return { name, content };
         } catch (error) {
           if (!isNotFoundError(error)) {
@@ -19657,7 +20229,7 @@ var init_agent_router = __esm({
        */
       async logUsage(task, agent, _projectPath) {
         try {
-          const logPath = path37.join(
+          const logPath = path38.join(
             process.env.HOME || "",
             ".prjct-cli",
             "projects",
@@ -19671,7 +20243,7 @@ var init_agent_router = __esm({
             projectId: this.projectId
           })}
 `;
-          await fs39.appendFile(logPath, entry);
+          await fs40.appendFile(logPath, entry);
         } catch (error) {
           if (!isNotFoundError(error)) {
             console.error(`Agent usage log error: ${getErrorMessage2(error)}`);
@@ -19684,14 +20256,14 @@ var init_agent_router = __esm({
 });
 
 // core/infrastructure/agent-detector.ts
-import path38 from "node:path";
+import path39 from "node:path";
 async 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 (await fileExists(path38.join(projectRoot, "CLAUDE.md"))) return true;
+  if (await fileExists(path39.join(projectRoot, "CLAUDE.md"))) return true;
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  if (await fileExists(path38.join(homeDir, ".claude"))) return true;
+  if (await fileExists(path39.join(homeDir, ".claude"))) return true;
   const cwd = process.cwd();
   if (cwd.includes("/.claude/") || cwd.includes("/claude-workspace/")) return true;
   return false;
@@ -19792,6 +20364,7 @@ var init_agent_service = __esm({
     init_agent_router();
     init_errors();
     init_agent_detector();
+    init_retry();
     init_();
     VALID_AGENT_TYPES = ["claude"];
     AgentService = class {
@@ -19806,20 +20379,23 @@ var init_agent_service = __esm({
       }
       /**
        * Initialize agent (Claude Code, Desktop, or Terminal)
+       * Wrapped with retry policy to handle transient failures
        */
       async initialize() {
         if (this.agent) return this.agent;
-        this.agentInfo = await detect2();
-        if (!this.agentInfo?.isSupported) {
-          throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
-        }
-        const agentType = this.agentInfo.type;
-        if (!agentType || !VALID_AGENT_TYPES.includes(agentType)) {
-          throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
-        }
-        const { default: Agent } = await globImport_infrastructure_agent(`../infrastructure/${agentType}-agent`);
-        this.agent = new Agent();
-        return this.agent;
+        return await defaultAgentRetryPolicy.execute(async () => {
+          this.agentInfo = await detect2();
+          if (!this.agentInfo?.isSupported) {
+            throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
+          }
+          const agentType = this.agentInfo.type;
+          if (!agentType || !VALID_AGENT_TYPES.includes(agentType)) {
+            throw AgentError.notSupported(this.agentInfo?.type ?? "unknown");
+          }
+          const { default: Agent } = await globImport_infrastructure_agent(`../infrastructure/${agentType}-agent`);
+          this.agent = new Agent();
+          return this.agent;
+        }, "agent-initialization");
       }
       /**
        * Get current agent info
@@ -20313,7 +20889,7 @@ var init_context_selector = __esm({
 });
 
 // core/services/file-categorizer.ts
-import path39 from "node:path";
+import path40 from "node:path";
 var HEURISTIC_PATTERNS, FileCategorizer, fileCategorizer;
 var init_file_categorizer = __esm({
   "core/services/file-categorizer.ts"() {
@@ -20409,8 +20985,8 @@ var init_file_categorizer = __esm({
               if (!domainPatterns.has(domain)) {
                 domainPatterns.set(domain, /* @__PURE__ */ new Set());
               }
-              const dir = path39.dirname(file.path);
-              domainPatterns.get(domain).add(`**/${path39.basename(dir)}/**`);
+              const dir = path40.dirname(file.path);
+              domainPatterns.get(domain).add(`**/${path40.basename(dir)}/**`);
             }
           }
         }
@@ -20595,7 +21171,7 @@ var init_file_categorizer = __esm({
 });
 
 // core/services/file-scorer.ts
-import path40 from "node:path";
+import path41 from "node:path";
 var RELEVANCE_THRESHOLD, CONFIG_PATTERNS, IMPORTANT_NAME_PATTERNS, FileScorer, fileScorer;
 var init_file_scorer = __esm({
   "core/services/file-scorer.ts"() {
@@ -20730,7 +21306,7 @@ var init_file_scorer = __esm({
        * Config files are always important
        */
       calculateConfigRelevance(stats) {
-        const filename = path40.basename(stats.path);
+        const filename = path41.basename(stats.path);
         for (const pattern of CONFIG_PATTERNS) {
           if (pattern.test(filename) || pattern.test(stats.path)) {
             return 20;
@@ -20743,13 +21319,13 @@ var init_file_scorer = __esm({
        * Certain filenames indicate importance
        */
       calculateNameRelevance(stats) {
-        const filename = path40.basename(stats.path);
+        const filename = path41.basename(stats.path);
         for (const pattern of IMPORTANT_NAME_PATTERNS) {
           if (pattern.test(filename)) {
             return 15;
           }
         }
-        const dir = path40.dirname(stats.path);
+        const dir = path41.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;
@@ -21184,8 +21760,8 @@ var init_memory_service = __esm({
 });
 
 // core/services/nested-context-resolver.ts
-import fs40 from "node:fs/promises";
-import path41 from "node:path";
+import fs41 from "node:fs/promises";
+import path42 from "node:path";
 var NestedContextResolver;
 var init_nested_context_resolver = __esm({
   "core/services/nested-context-resolver.ts"() {
@@ -21199,7 +21775,7 @@ var init_nested_context_resolver = __esm({
       rootPath;
       monoInfo = null;
       constructor(rootPath) {
-        this.rootPath = path41.resolve(rootPath);
+        this.rootPath = path42.resolve(rootPath);
       }
       /**
        * Initialize the resolver with monorepo detection
@@ -21212,14 +21788,14 @@ var init_nested_context_resolver = __esm({
        */
       async discoverContextFiles() {
         const contexts = [];
-        const rootPrjctPath = path41.join(this.rootPath, "PRJCT.md");
+        const rootPrjctPath = path42.join(this.rootPath, "PRJCT.md");
         if (await fileExists2(rootPrjctPath)) {
           const rootContext = await this.loadContext(rootPrjctPath, null);
           contexts.push(rootContext);
         }
         if (this.monoInfo?.isMonorepo) {
           for (const pkg of this.monoInfo.packages) {
-            const pkgPrjctPath = path41.join(pkg.path, "PRJCT.md");
+            const pkgPrjctPath = path42.join(pkg.path, "PRJCT.md");
             if (await fileExists2(pkgPrjctPath)) {
               const parentContext = contexts.find((c) => c.depth === 0) || null;
               const pkgContext = await this.loadContext(pkgPrjctPath, parentContext, pkg);
@@ -21238,9 +21814,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 fs40.readFile(filePath, "utf-8");
-        const relativePath = path41.relative(this.rootPath, filePath);
-        const depth = relativePath.split(path41.sep).length - 1;
+        const content = await fs41.readFile(filePath, "utf-8");
+        const relativePath = path42.relative(this.rootPath, filePath);
+        const depth = relativePath.split(path42.sep).length - 1;
         return {
           path: filePath,
           relativePath,
@@ -21294,14 +21870,14 @@ var init_nested_context_resolver = __esm({
         const scan = /* @__PURE__ */ __name(async (currentDir, depth) => {
           if (depth > 5) return;
           try {
-            const entries = await fs40.readdir(currentDir, { withFileTypes: true });
+            const entries = await fs41.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 = path41.join(currentDir, entry.name);
-                const prjctPath = path41.join(subDir, "PRJCT.md");
+                const subDir = path42.join(currentDir, entry.name);
+                const prjctPath = path42.join(subDir, "PRJCT.md");
                 if (await fileExists2(prjctPath) && !existingPaths.has(prjctPath)) {
                   const parent = this.findParentContext(prjctPath, existing.concat(found));
                   const context2 = await this.loadContext(prjctPath, parent);
@@ -21324,10 +21900,10 @@ var init_nested_context_resolver = __esm({
        * Find the parent context for a given path
        */
       findParentContext(filePath, contexts) {
-        const fileDir = path41.dirname(filePath);
+        const fileDir = path42.dirname(filePath);
         const sorted = [...contexts].sort((a, b) => b.depth - a.depth);
         for (const ctx of sorted) {
-          const ctxDir = path41.dirname(ctx.path);
+          const ctxDir = path42.dirname(ctx.path);
           if (fileDir.startsWith(ctxDir) && fileDir !== ctxDir) {
             return ctx;
           }
@@ -21340,10 +21916,10 @@ var init_nested_context_resolver = __esm({
        */
       async resolveContextForPath(targetPath) {
         const contexts = await this.discoverContextFiles();
-        const targetDir = path41.resolve(targetPath);
+        const targetDir = path42.resolve(targetPath);
         let bestMatch = null;
         for (const ctx of contexts) {
-          const ctxDir = path41.dirname(ctx.path);
+          const ctxDir = path42.dirname(ctx.path);
           if (targetDir.startsWith(ctxDir)) {
             if (!bestMatch || ctx.depth > bestMatch.depth) {
               bestMatch = ctx;
@@ -21435,14 +22011,14 @@ ${content}`);
        */
       async discoverAgentFiles() {
         const agentFiles = [];
-        const rootAgentsPath = path41.join(this.rootPath, "AGENTS.md");
+        const rootAgentsPath = path42.join(this.rootPath, "AGENTS.md");
         if (await fileExists2(rootAgentsPath)) {
           const rootAgents = await this.loadAgents(rootAgentsPath, null);
           agentFiles.push(rootAgents);
         }
         if (this.monoInfo?.isMonorepo) {
           for (const pkg of this.monoInfo.packages) {
-            const pkgAgentsPath = path41.join(pkg.path, "AGENTS.md");
+            const pkgAgentsPath = path42.join(pkg.path, "AGENTS.md");
             if (await fileExists2(pkgAgentsPath)) {
               const parentAgents = agentFiles.find((a) => a.depth === 0) || null;
               const pkgAgents = await this.loadAgents(pkgAgentsPath, parentAgents, pkg);
@@ -21461,9 +22037,9 @@ ${content}`);
        * Load a single AGENTS.md file into a NestedAgents structure
        */
       async loadAgents(filePath, parent, pkg = null) {
-        const content = await fs40.readFile(filePath, "utf-8");
-        const relativePath = path41.relative(this.rootPath, filePath);
-        const depth = relativePath.split(path41.sep).length - 1;
+        const content = await fs41.readFile(filePath, "utf-8");
+        const relativePath = path42.relative(this.rootPath, filePath);
+        const depth = relativePath.split(path42.sep).length - 1;
         return {
           path: filePath,
           relativePath,
@@ -21596,14 +22172,14 @@ ${content}`);
         const scan = /* @__PURE__ */ __name(async (currentDir, depth) => {
           if (depth > 5) return;
           try {
-            const entries = await fs40.readdir(currentDir, { withFileTypes: true });
+            const entries = await fs41.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 = path41.join(currentDir, entry.name);
-                const agentsPath = path41.join(subDir, "AGENTS.md");
+                const subDir = path42.join(currentDir, entry.name);
+                const agentsPath = path42.join(subDir, "AGENTS.md");
                 if (await fileExists2(agentsPath) && !existingPaths.has(agentsPath)) {
                   const parent = this.findParentAgents(agentsPath, existing.concat(found));
                   const agents = await this.loadAgents(agentsPath, parent);
@@ -21626,10 +22202,10 @@ ${content}`);
        * Find the parent agents file for a given path
        */
       findParentAgents(filePath, agentFiles) {
-        const fileDir = path41.dirname(filePath);
+        const fileDir = path42.dirname(filePath);
         const sorted = [...agentFiles].sort((a, b) => b.depth - a.depth);
         for (const agents of sorted) {
-          const agentsDir = path41.dirname(agents.path);
+          const agentsDir = path42.dirname(agents.path);
           if (fileDir.startsWith(agentsDir) && fileDir !== agentsDir) {
             return agents;
           }
@@ -21642,10 +22218,10 @@ ${content}`);
        */
       async resolveAgentsForPath(targetPath) {
         const agentFiles = await this.discoverAgentFiles();
-        const targetDir = path41.resolve(targetPath);
+        const targetDir = path42.resolve(targetPath);
         let bestMatch = null;
         for (const agents of agentFiles) {
-          const agentsDir = path41.dirname(agents.path);
+          const agentsDir = path42.dirname(agents.path);
           if (targetDir.startsWith(agentsDir)) {
             if (!bestMatch || agents.depth > bestMatch.depth) {
               bestMatch = agents;
@@ -22087,16 +22663,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs61 = await import("node:fs/promises");
-        const path73 = await import("node:path");
+        const fs62 = await import("node:fs/promises");
+        const path74 = await import("node:path");
         try {
-          const files = await fs61.readdir(this.projectPath);
+          const files = await fs62.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 = path73.join(this.projectPath, "package.json");
-            const pkgContent = await fs61.readFile(pkgPath, "utf-8");
+            const pkgPath = path74.join(this.projectPath, "package.json");
+            const pkgContent = await fs62.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -22132,32 +22708,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs61 = await import("node:fs/promises");
-        const path73 = await import("node:path");
+        const fs62 = await import("node:fs/promises");
+        const path74 = await import("node:path");
         const os22 = await import("node:os");
         const agents = [];
         try {
-          await fs61.access(path73.join(os22.homedir(), ".claude"));
+          await fs62.access(path74.join(os22.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs61.access(path73.join(this.projectPath, ".cursorrules"));
+          await fs62.access(path74.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs61.access(path73.join(this.projectPath, ".windsurfrules"));
+          await fs62.access(path74.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs61.access(path73.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs62.access(path74.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs61.access(path73.join(os22.homedir(), ".gemini"));
+          await fs62.access(path74.join(os22.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -22167,17 +22743,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs61 = await import("node:fs/promises");
-        const path73 = await import("node:path");
+        const fs62 = await import("node:fs/promises");
+        const path74 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs61.readdir(this.projectPath);
+          const files = await fs62.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path73.join(this.projectPath, "package.json");
-            const pkgContent = await fs61.readFile(pkgPath, "utf-8");
+            const pkgPath = path74.join(this.projectPath, "package.json");
+            const pkgContent = await fs62.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -22284,14 +22860,14 @@ var init_wizard = __esm({
 
 // core/context/generator.ts
 import { exec as exec10 } from "node:child_process";
-import fs41 from "node:fs/promises";
-import path42 from "node:path";
+import fs42 from "node:fs/promises";
+import path43 from "node:path";
 import { promisify as promisify11 } from "node:util";
 async function generateContext(projectId, repoPath) {
   const _globalPath = path_manager_default.getGlobalProjectPath(projectId);
   const contextPath = path_manager_default.getContextPath(projectId);
   const storage = getStorage(projectId);
-  await fs41.mkdir(contextPath, { recursive: true });
+  await fs42.mkdir(contextPath, { recursive: true });
   const project = await storage.read(["project"]) || {};
   const taskPaths = await storage.list(["task"]);
   const featurePaths = await storage.list(["feature"]);
@@ -22373,8 +22949,8 @@ async function getPackageData(repoPath) {
     scripts: {}
   };
   try {
-    const pkgPath = path42.join(repoPath, "package.json");
-    const pkg = JSON.parse(await fs41.readFile(pkgPath, "utf-8"));
+    const pkgPath = path43.join(repoPath, "package.json");
+    const pkg = JSON.parse(await fs42.readFile(pkgPath, "utf-8"));
     data.dependencies = pkg.dependencies || {};
     data.devDependencies = pkg.devDependencies || {};
     data.scripts = pkg.scripts || {};
@@ -22383,7 +22959,7 @@ async function getPackageData(repoPath) {
   return data;
 }
 async function generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath) {
-  const projectName = project.name || path42.basename(repoPath);
+  const projectName = project.name || path43.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");
@@ -22458,7 +23034,7 @@ ${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || "Specialis
     \u2514\u2500\u2500 pending.json
 \`\`\`
 `;
-  await fs41.writeFile(path42.join(contextPath, "CLAUDE.md"), content, "utf-8");
+  await fs42.writeFile(path43.join(contextPath, "CLAUDE.md"), content, "utf-8");
 }
 async function generateNowMd(contextPath, tasks) {
   const currentTask = tasks.find((t) => t.status === "in_progress");
@@ -22473,7 +23049,7 @@ async function generateNowMd(contextPath, tasks) {
 
 _No active task. Use /p:now to start._
 `;
-  await fs41.writeFile(path42.join(contextPath, "now.md"), content, "utf-8");
+  await fs42.writeFile(path43.join(contextPath, "now.md"), content, "utf-8");
 }
 async function generateQueueMd(contextPath, tasks) {
   const pendingTasks = tasks.filter((t) => t.status === "pending");
@@ -22481,7 +23057,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 fs41.writeFile(path42.join(contextPath, "queue.md"), content, "utf-8");
+  await fs42.writeFile(path43.join(contextPath, "queue.md"), content, "utf-8");
 }
 async function generateSummaryMd(contextPath, project, gitData, pkgData) {
   const content = `# PROJECT SUMMARY
@@ -22501,7 +23077,7 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 - Production: ${Object.keys(pkgData.dependencies).length}
 - Dev: ${Object.keys(pkgData.devDependencies).length}
 `;
-  await fs41.writeFile(path42.join(contextPath, "summary.md"), content, "utf-8");
+  await fs42.writeFile(path43.join(contextPath, "summary.md"), content, "utf-8");
 }
 var execAsync7;
 var init_generator = __esm({
@@ -22522,8 +23098,8 @@ var init_generator = __esm({
 
 // core/domain/analyzer.ts
 import { exec as execCallback6 } from "node:child_process";
-import fs42 from "node:fs/promises";
-import path43 from "node:path";
+import fs43 from "node:fs/promises";
+import path44 from "node:path";
 import { promisify as promisify12 } from "node:util";
 var exec11, CodebaseAnalyzer, analyzer, analyzer_default2;
 var init_analyzer2 = __esm({
@@ -22547,8 +23123,8 @@ var init_analyzer2 = __esm({
        */
       async readPackageJson() {
         try {
-          const packagePath = path43.join(this.projectPath, "package.json");
-          const content = await fs42.readFile(packagePath, "utf-8");
+          const packagePath = path44.join(this.projectPath, "package.json");
+          const content = await fs43.readFile(packagePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -22562,8 +23138,8 @@ var init_analyzer2 = __esm({
        */
       async readCargoToml() {
         try {
-          const cargoPath = path43.join(this.projectPath, "Cargo.toml");
-          return await fs42.readFile(cargoPath, "utf-8");
+          const cargoPath = path44.join(this.projectPath, "Cargo.toml");
+          return await fs43.readFile(cargoPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -22576,8 +23152,8 @@ var init_analyzer2 = __esm({
        */
       async readRequirements() {
         try {
-          const reqPath = path43.join(this.projectPath, "requirements.txt");
-          return await fs42.readFile(reqPath, "utf-8");
+          const reqPath = path44.join(this.projectPath, "requirements.txt");
+          return await fs43.readFile(reqPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -22590,8 +23166,8 @@ var init_analyzer2 = __esm({
        */
       async readGoMod() {
         try {
-          const goModPath = path43.join(this.projectPath, "go.mod");
-          return await fs42.readFile(goModPath, "utf-8");
+          const goModPath = path44.join(this.projectPath, "go.mod");
+          return await fs43.readFile(goModPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -22604,8 +23180,8 @@ var init_analyzer2 = __esm({
        */
       async readGemfile() {
         try {
-          const gemfilePath = path43.join(this.projectPath, "Gemfile");
-          return await fs42.readFile(gemfilePath, "utf-8");
+          const gemfilePath = path44.join(this.projectPath, "Gemfile");
+          return await fs43.readFile(gemfilePath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -22618,8 +23194,8 @@ var init_analyzer2 = __esm({
        */
       async readMixExs() {
         try {
-          const mixPath = path43.join(this.projectPath, "mix.exs");
-          return await fs42.readFile(mixPath, "utf-8");
+          const mixPath = path44.join(this.projectPath, "mix.exs");
+          return await fs43.readFile(mixPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -22632,8 +23208,8 @@ var init_analyzer2 = __esm({
        */
       async readPomXml() {
         try {
-          const pomPath = path43.join(this.projectPath, "pom.xml");
-          return await fs42.readFile(pomPath, "utf-8");
+          const pomPath = path44.join(this.projectPath, "pom.xml");
+          return await fs43.readFile(pomPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -22646,8 +23222,8 @@ var init_analyzer2 = __esm({
        */
       async readComposerJson() {
         try {
-          const composerPath = path43.join(this.projectPath, "composer.json");
-          const content = await fs42.readFile(composerPath, "utf-8");
+          const composerPath = path44.join(this.projectPath, "composer.json");
+          const content = await fs43.readFile(composerPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -22661,8 +23237,8 @@ var init_analyzer2 = __esm({
        */
       async readPyprojectToml() {
         try {
-          const pyprojectPath = path43.join(this.projectPath, "pyproject.toml");
-          return await fs42.readFile(pyprojectPath, "utf-8");
+          const pyprojectPath = path44.join(this.projectPath, "pyproject.toml");
+          return await fs43.readFile(pyprojectPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -22698,7 +23274,7 @@ var init_analyzer2 = __esm({
        */
       async listConfigFiles() {
         try {
-          const entries = await fs42.readdir(this.projectPath);
+          const entries = await fs43.readdir(this.projectPath);
           const configPatterns = [
             /^package\.json$/,
             /^Cargo\.toml$/,
@@ -22728,7 +23304,7 @@ var init_analyzer2 = __esm({
        */
       async listDirectories() {
         try {
-          const entries = await fs42.readdir(this.projectPath, { withFileTypes: true });
+          const entries = await fs43.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)) {
@@ -22799,7 +23375,7 @@ var init_analyzer2 = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs42.access(path43.join(this.projectPath, filename));
+          await fs43.access(path44.join(this.projectPath, filename));
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -22813,8 +23389,8 @@ var init_analyzer2 = __esm({
        */
       async readFile(relativePath) {
         try {
-          const fullPath = path43.join(this.projectPath, relativePath);
-          return await fs42.readFile(fullPath, "utf-8");
+          const fullPath = path44.join(this.projectPath, relativePath);
+          return await fs43.readFile(fullPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -23062,8 +23638,8 @@ var analysis_exports = {};
 __export(analysis_exports, {
   AnalysisCommands: () => AnalysisCommands
 });
-import fs43 from "node:fs/promises";
-import path44 from "node:path";
+import fs44 from "node:fs/promises";
+import path45 from "node:path";
 import prompts2 from "prompts";
 var AnalysisCommands;
 var init_analysis2 = __esm({
@@ -23152,7 +23728,7 @@ var init_analysis2 = __esm({
         lines.push("# Repository Analysis\n");
         lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
 `);
-        const projectName = path44.basename(projectPath);
+        const projectName = path45.basename(projectPath);
         lines.push(`## Project: ${projectName}
 `);
         lines.push("## Stack Detected\n");
@@ -23292,10 +23868,10 @@ var init_analysis2 = __esm({
             }
             return { success: result2.success };
           }
-          const claudeMdPath = path44.join(globalPath, "context", "CLAUDE.md");
+          const claudeMdPath = path45.join(globalPath, "context", "CLAUDE.md");
           let existingContent = null;
           try {
-            existingContent = await fs43.readFile(claudeMdPath, "utf-8");
+            existingContent = await fs44.readFile(claudeMdPath, "utf-8");
           } catch {
           }
           const isNonInteractive = !process.stdin.isTTY || options.json;
@@ -23317,7 +23893,7 @@ var init_analysis2 = __esm({
             }
             let newContent;
             try {
-              newContent = await fs43.readFile(claudeMdPath, "utf-8");
+              newContent = await fs44.readFile(claudeMdPath, "utf-8");
             } catch {
               newContent = "";
             }
@@ -23341,7 +23917,7 @@ var init_analysis2 = __esm({
             }
             const restoreOriginal = /* @__PURE__ */ __name(async () => {
               if (existingContent != null) {
-                await fs43.writeFile(claudeMdPath, existingContent, "utf-8");
+                await fs44.writeFile(claudeMdPath, existingContent, "utf-8");
               }
             }, "restoreOriginal");
             if (isNonInteractive) {
@@ -23563,7 +24139,7 @@ ${formatFullDiff(diff)}`);
           let projectName = "Unknown";
           try {
             const projectJson = JSON.parse(
-              await fs43.readFile(path44.join(globalPath, "project.json"), "utf-8")
+              await fs44.readFile(path45.join(globalPath, "project.json"), "utf-8")
             );
             projectName = projectJson.name || "Unknown";
           } catch {
@@ -23772,8 +24348,15 @@ ${formatFullDiff(diff)}`);
       }
       /**
        * prjct verify - Verify integrity of sealed analysis (PRJ-263)
+       *
+       * Modes:
+       * - Default: Cryptographic verification (signature check)
+       * - --semantic: Semantic verification (data accuracy check, PRJ-270)
        */
       async verify(projectPath = process.cwd(), options = {}) {
+        if (options.semantic) {
+          return this.semanticVerify(projectPath, options);
+        }
         try {
           const initResult = await this.ensureProjectInit(projectPath);
           if (!initResult.success) return initResult;
@@ -23799,6 +24382,72 @@ ${formatFullDiff(diff)}`);
           return { success: false, error: errMsg };
         }
       }
+      /**
+       * prjct analysis verify --semantic - Semantic verification of analysis results (PRJ-270)
+       *
+       * Validates that analysis data matches actual project state:
+       * - Frameworks exist in package.json
+       * - Languages match file extensions
+       * - Pattern locations reference real files
+       * - File count is accurate
+       * - Anti-pattern files exist
+       */
+      async semanticVerify(projectPath = process.cwd(), options = {}) {
+        try {
+          const initResult = await this.ensureProjectInit(projectPath);
+          if (!initResult.success) return initResult;
+          const projectId = await config_manager_default.getProjectId(projectPath);
+          if (!projectId) {
+            if (options.json) {
+              console.log(JSON.stringify({ success: false, error: "No project ID found" }));
+            } else {
+              output_default.fail("No project ID found");
+            }
+            return { success: false, error: "No project ID found" };
+          }
+          const globalPath = path_manager_default.getGlobalProjectPath(projectId);
+          let repoPath = projectPath;
+          try {
+            const projectJson = JSON.parse(
+              await fs44.readFile(path45.join(globalPath, "project.json"), "utf-8")
+            );
+            repoPath = projectJson.repoPath || projectPath;
+          } catch {
+          }
+          const result = await analysisStorage.semanticVerify(projectId, repoPath);
+          if (options.json) {
+            console.log(JSON.stringify(result));
+            return { success: result.passed, data: result };
+          }
+          console.log("");
+          if (result.passed) {
+            output_default.done("Semantic verification passed");
+            console.log(
+              `  ${result.passedCount}/${result.checks.length} checks passed (${result.totalMs}ms)`
+            );
+          } else {
+            output_default.fail("Semantic verification failed");
+            console.log(`  ${result.failedCount}/${result.checks.length} checks failed`);
+          }
+          console.log("");
+          console.log("Check Results:");
+          for (const check of result.checks) {
+            const icon = check.passed ? "\u2713" : "\u2717";
+            const status = check.passed ? `${check.output} (${check.durationMs}ms)` : check.error || "Failed";
+            console.log(`  ${icon} ${check.name}: ${status}`);
+          }
+          console.log("");
+          return { success: result.passed, data: result };
+        } catch (error) {
+          const errMsg = getErrorMessage2(error);
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: errMsg }));
+          } else {
+            output_default.fail(errMsg);
+          }
+          return { success: false, error: errMsg };
+        }
+      }
       /**
        * Get session activity stats from today's events
        * @see PRJ-89
@@ -23954,7 +24603,7 @@ var planning_exports = {};
 __export(planning_exports, {
   PlanningCommands: () => PlanningCommands
 });
-import path45 from "node:path";
+import path46 from "node:path";
 async function getAnalysisCommands() {
   if (!_analysisCommands) {
     const { AnalysisCommands: AnalysisCommands2 } = await Promise.resolve().then(() => (init_analysis2(), analysis_exports));
@@ -24062,7 +24711,7 @@ var init_planning = __esm({
             );
           }
           for (const [filePath, content] of Object.entries(baseFiles)) {
-            await tool_registry_default.get("Write")(path45.join(globalPath, filePath), content);
+            await tool_registry_default.get("Write")(path46.join(globalPath, filePath), content);
           }
           const isEmpty = await this._detectEmptyDirectory(projectPath);
           const hasCode = await this._detectExistingCode(projectPath);
@@ -24089,7 +24738,7 @@ var init_planning = __esm({
               return { success: true, mode: "blank_no_idea", projectId, wizard: wizardResult };
             }
             output_default.spin("architect mode...");
-            const sessionPath = path45.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path46.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -24275,7 +24924,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 = path45.join(globalPath, "planning", "architect-session.md");
+          const planPath = path46.join(globalPath, "planning", "architect-session.md");
           let planContent;
           try {
             planContent = await file_helper_exports.readFile(planPath);
@@ -24350,7 +24999,7 @@ ${"=".repeat(60)}`);
           if (isComplex) {
             output_default.spin("analyzing idea...");
             const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-            const sessionPath = path45.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path46.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -24406,10 +25055,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!featureName) {
             output_default.spin("loading specs...");
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
-            const specsPath2 = path45.join(globalPath2, "planning", "specs");
+            const specsPath2 = path46.join(globalPath2, "planning", "specs");
             try {
-              const fs61 = await import("node:fs/promises");
-              const files = await fs61.readdir(specsPath2);
+              const fs62 = await import("node:fs/promises");
+              const files = await fs62.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -24432,10 +25081,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           }
           output_default.spin("creating spec...");
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-          const specsPath = path45.join(globalPath, "planning", "specs");
+          const specsPath = path46.join(globalPath, "planning", "specs");
           await file_helper_exports.ensureDir(specsPath);
           const slug = featureName.toLowerCase().replace(/\s+/g, "-");
-          const specFile = path45.join(specsPath, `${slug}.md`);
+          const specFile = path46.join(specsPath, `${slug}.md`);
           const specContent = `# Specification: ${featureName}
 
 ## Overview
@@ -24623,8 +25272,8 @@ var init_project_service = __esm({
 
 // core/services/staleness-checker.ts
 import { exec as exec12 } from "node:child_process";
-import fs44 from "node:fs/promises";
-import path46 from "node:path";
+import fs45 from "node:fs/promises";
+import path47 from "node:path";
 import { promisify as promisify13 } from "node:util";
 var execAsync8, DEFAULT_CONFIG, StalenessChecker, createStalenessChecker;
 var init_staleness_checker = __esm({
@@ -24674,10 +25323,10 @@ var init_staleness_checker = __esm({
           significantChanges: []
         };
         try {
-          const projectJsonPath = path46.join(path_manager_default.getGlobalProjectPath(projectId), "project.json");
+          const projectJsonPath = path47.join(path_manager_default.getGlobalProjectPath(projectId), "project.json");
           let projectJson = {};
           try {
-            projectJson = JSON.parse(await fs44.readFile(projectJsonPath, "utf-8"));
+            projectJson = JSON.parse(await fs45.readFile(projectJsonPath, "utf-8"));
           } catch {
             status.isStale = true;
             status.reason = "No sync history found. Run `prjct sync` to initialize.";
@@ -25139,7 +25788,7 @@ var init_formatters = __esm({
 // core/ai-tools/registry.ts
 import { exec as exec13 } from "node:child_process";
 import os13 from "node:os";
-import path47 from "node:path";
+import path48 from "node:path";
 import { promisify as promisify14 } from "node:util";
 function getAIToolConfig(id) {
   return AI_TOOLS[id] || null;
@@ -25157,16 +25806,16 @@ async function detectInstalledTools(repoPath = process.cwd()) {
   if (await commandExists("claude")) {
     detected.push("claude");
   }
-  if (await commandExists("cursor") || await fileExists(path47.join(repoPath, ".cursor"))) {
+  if (await commandExists("cursor") || await fileExists(path48.join(repoPath, ".cursor"))) {
     detected.push("cursor");
   }
-  if (await fileExists(path47.join(repoPath, ".github"))) {
+  if (await fileExists(path48.join(repoPath, ".github"))) {
     detected.push("copilot");
   }
-  if (await commandExists("windsurf") || await fileExists(path47.join(repoPath, ".windsurf"))) {
+  if (await commandExists("windsurf") || await fileExists(path48.join(repoPath, ".windsurf"))) {
     detected.push("windsurf");
   }
-  if (await fileExists(path47.join(repoPath, ".continue")) || await fileExists(path47.join(os13.homedir(), ".continue"))) {
+  if (await fileExists(path48.join(repoPath, ".continue")) || await fileExists(path48.join(os13.homedir(), ".continue"))) {
     detected.push("continue");
   }
   return detected;
@@ -25244,8 +25893,8 @@ var init_registry = __esm({
 });
 
 // core/ai-tools/generator.ts
-import fs45 from "node:fs/promises";
-import path48 from "node:path";
+import fs46 from "node:fs/promises";
+import path49 from "node:path";
 async function generateAIToolContexts(context2, globalPath, repoPath, toolIds = DEFAULT_AI_TOOLS) {
   const results = [];
   for (const toolId of toolIds) {
@@ -25280,13 +25929,13 @@ async function generateForTool(context2, config, globalPath, repoPath) {
     let content = formatter(context2, config);
     let outputPath;
     if (config.outputPath === "repo") {
-      outputPath = path48.join(repoPath, config.outputFile);
+      outputPath = path49.join(repoPath, config.outputFile);
     } else {
-      outputPath = path48.join(globalPath, "context", config.outputFile);
+      outputPath = path49.join(globalPath, "context", config.outputFile);
     }
-    await fs45.mkdir(path48.dirname(outputPath), { recursive: true });
+    await fs46.mkdir(path49.dirname(outputPath), { recursive: true });
     try {
-      const existingContent = await fs45.readFile(outputPath, "utf-8");
+      const existingContent = await fs46.readFile(outputPath, "utf-8");
       const validation = validatePreserveBlocks(existingContent);
       if (!validation.valid) {
         console.warn(`\u26A0\uFE0F  ${config.outputFile} has invalid preserve blocks:`);
@@ -25297,7 +25946,7 @@ async function generateForTool(context2, config, globalPath, repoPath) {
       content = mergePreservedSections(content, existingContent);
     } catch {
     }
-    await fs45.writeFile(outputPath, content, "utf-8");
+    await fs46.writeFile(outputPath, content, "utf-8");
     return {
       toolId: config.id,
       outputFile: config.outputFile,
@@ -25337,8 +25986,8 @@ var init_ai_tools = __esm({
 });
 
 // core/domain/bm25.ts
-import fs46 from "node:fs/promises";
-import path49 from "node:path";
+import fs47 from "node:fs/promises";
+import path50 from "node:path";
 function splitIdentifier(identifier) {
   return identifier.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[-_./]/g, " ").toLowerCase().split(/\s+/).filter((w) => w.length > 1);
 }
@@ -25405,16 +26054,16 @@ function tokenizeFile(content, filePath) {
 }
 async function listFiles2(dir, projectPath) {
   const files = [];
-  const entries = await fs46.readdir(dir, { withFileTypes: true });
+  const entries = await fs47.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = path49.join(dir, entry.name);
+    const fullPath = path50.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles2(fullPath, projectPath));
     } else if (entry.isFile()) {
-      const ext = path49.extname(entry.name).toLowerCase();
+      const ext = path50.extname(entry.name).toLowerCase();
       if (INDEXABLE_EXTENSIONS.has(ext)) {
-        files.push(path49.relative(projectPath, fullPath));
+        files.push(path50.relative(projectPath, fullPath));
       }
     }
   }
@@ -25431,7 +26080,7 @@ async function buildIndex(projectPath) {
     const results = await Promise.all(
       batch.map(async (filePath) => {
         try {
-          const content = await fs46.readFile(path49.join(projectPath, filePath), "utf-8");
+          const content = await fs47.readFile(path50.join(projectPath, filePath), "utf-8");
           const tokens = tokenizeFile(content, filePath);
           return { filePath, tokens };
         } catch {
@@ -25609,8 +26258,8 @@ var init_bm25 = __esm({
 });
 
 // core/domain/import-graph.ts
-import fs47 from "node:fs/promises";
-import path50 from "node:path";
+import fs48 from "node:fs/promises";
+import path51 from "node:path";
 function extractImportSources(content) {
   const sources = [];
   let match;
@@ -25626,17 +26275,17 @@ function extractImportSources(content) {
 async function resolveImport2(source, fromFile, projectPath) {
   let basePath;
   if (source.startsWith("@/")) {
-    basePath = path50.join(projectPath, "src", source.slice(2));
+    basePath = path51.join(projectPath, "src", source.slice(2));
   } else {
-    const fromDir = path50.dirname(path50.join(projectPath, fromFile));
-    basePath = path50.resolve(fromDir, source);
+    const fromDir = path51.dirname(path51.join(projectPath, fromFile));
+    basePath = path51.resolve(fromDir, source);
   }
   for (const ext of RESOLVE_EXTENSIONS) {
     const fullPath = basePath + ext;
     try {
-      const stat = await fs47.stat(fullPath);
+      const stat = await fs48.stat(fullPath);
       if (stat.isFile()) {
-        return path50.relative(projectPath, fullPath);
+        return path51.relative(projectPath, fullPath);
       }
     } catch {
     }
@@ -25645,16 +26294,16 @@ async function resolveImport2(source, fromFile, projectPath) {
 }
 async function listFiles3(dir, projectPath) {
   const files = [];
-  const entries = await fs47.readdir(dir, { withFileTypes: true });
+  const entries = await fs48.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (SKIP_DIRS2.has(entry.name)) continue;
-    const fullPath = path50.join(dir, entry.name);
+    const fullPath = path51.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles3(fullPath, projectPath));
     } else if (entry.isFile()) {
-      const ext = path50.extname(entry.name).toLowerCase();
+      const ext = path51.extname(entry.name).toLowerCase();
       if (INDEXABLE_EXTENSIONS2.has(ext)) {
-        files.push(path50.relative(projectPath, fullPath));
+        files.push(path51.relative(projectPath, fullPath));
       }
     }
   }
@@ -25671,7 +26320,7 @@ async function buildGraph(projectPath) {
     const results = await Promise.all(
       batch.map(async (filePath) => {
         try {
-          const content = await fs47.readFile(path50.join(projectPath, filePath), "utf-8");
+          const content = await fs48.readFile(path51.join(projectPath, filePath), "utf-8");
           const sources = extractImportSources(content);
           const resolved = [];
           for (const source of sources) {
@@ -25806,22 +26455,22 @@ var init_change_propagator = __esm({
 });
 
 // core/domain/file-hasher.ts
-import fs48 from "node:fs/promises";
-import path51 from "node:path";
+import fs49 from "node:fs/promises";
+import path52 from "node:path";
 async function listProjectFiles(dir, projectPath) {
   const files = [];
-  const entries = await fs48.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs49.readdir(dir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     const name = String(entry.name);
     if (SKIP_DIRS3.has(name)) continue;
     if (name.startsWith(".") && name !== ".env.example") continue;
-    const fullPath = path51.join(dir, name);
+    const fullPath = path52.join(dir, name);
     if (entry.isDirectory()) {
       files.push(...await listProjectFiles(fullPath, projectPath));
     } else if (entry.isFile()) {
-      const ext = path51.extname(name).toLowerCase();
+      const ext = path52.extname(name).toLowerCase();
       if (INDEXABLE_EXTENSIONS3.has(ext)) {
-        files.push(path51.relative(projectPath, fullPath));
+        files.push(path52.relative(projectPath, fullPath));
       }
     }
   }
@@ -25847,10 +26496,10 @@ async function computeHashes(projectPath) {
     const results = await Promise.all(
       batch.map(async (filePath) => {
         try {
-          const fullPath = path51.join(projectPath, filePath);
+          const fullPath = path52.join(projectPath, filePath);
           const [content, stat] = await Promise.all([
-            fs48.readFile(fullPath, "utf-8"),
-            fs48.stat(fullPath)
+            fs49.readFile(fullPath, "utf-8"),
+            fs49.stat(fullPath)
           ]);
           return {
             path: filePath,
@@ -26093,8 +26742,8 @@ var init_git_cochange = __esm({
 });
 
 // core/services/context-generator.ts
-import fs49 from "node:fs/promises";
-import path52 from "node:path";
+import fs50 from "node:fs/promises";
+import path53 from "node:path";
 var ContextFileGenerator;
 var init_context_generator = __esm({
   "core/services/context-generator.ts"() {
@@ -26119,10 +26768,10 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs49.readFile(filePath, "utf-8");
+          const existingContent = await fs50.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
-            const filename = path52.basename(filePath);
+            const filename = path53.basename(filePath);
             console.warn(`\u26A0\uFE0F  ${filename} has invalid preserve blocks:`);
             for (const error of validation.errors) {
               console.warn(`   ${error}`);
@@ -26131,13 +26780,13 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs49.writeFile(filePath, finalContent, "utf-8");
+        await fs50.writeFile(filePath, finalContent, "utf-8");
       }
       /**
        * Generate all context files in parallel
        */
       async generate(git, stats, commands, agents, sources) {
-        const contextPath = path52.join(this.config.globalPath, "context");
+        const contextPath = path53.join(this.config.globalPath, "context");
         await Promise.all([
           this.generateClaudeMd(contextPath, git, stats, commands, agents, sources),
           this.generateNowMd(contextPath),
@@ -26237,7 +26886,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        const claudePath = path52.join(contextPath, "CLAUDE.md");
+        const claudePath = path53.join(contextPath, "CLAUDE.md");
         await this.writeWithPreservation(claudePath, content);
       }
       /**
@@ -26246,8 +26895,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path52.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs49.readFile(statePath, "utf-8"));
+          const statePath = path53.join(this.config.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs50.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -26263,7 +26912,7 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await this.writeWithPreservation(path52.join(contextPath, "now.md"), content);
+        await this.writeWithPreservation(path53.join(contextPath, "now.md"), content);
       }
       /**
        * Generate next.md - task queue
@@ -26271,15 +26920,15 @@ Use \`p. task "description"\` to start working.
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path52.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs49.readFile(queuePath, "utf-8"));
+          const queuePath = path53.join(this.config.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs50.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(path52.join(contextPath, "next.md"), content);
+        await this.writeWithPreservation(path53.join(contextPath, "next.md"), content);
       }
       /**
        * Generate ideas.md - captured ideas
@@ -26287,15 +26936,15 @@ ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}
       async generateIdeasMd(contextPath) {
         let ideas = { ideas: [] };
         try {
-          const ideasPath = path52.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs49.readFile(ideasPath, "utf-8"));
+          const ideasPath = path53.join(this.config.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs50.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(path52.join(contextPath, "ideas.md"), content);
+        await this.writeWithPreservation(path53.join(contextPath, "ideas.md"), content);
       }
       /**
        * Generate shipped.md - completed features
@@ -26305,8 +26954,8 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
           shipped: []
         };
         try {
-          const shippedPath = path52.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs49.readFile(shippedPath, "utf-8"));
+          const shippedPath = path53.join(this.config.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs50.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -26315,7 +26964,7 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await this.writeWithPreservation(path52.join(contextPath, "shipped.md"), content);
+        await this.writeWithPreservation(path53.join(contextPath, "shipped.md"), content);
       }
       // ==========================================================================
       // MONOREPO SUPPORT
@@ -26344,9 +26993,9 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
             commands,
             agents
           );
-          const claudePath = path52.join(pkg.path, "CLAUDE.md");
+          const claudePath = path53.join(pkg.path, "CLAUDE.md");
           await this.writeWithPreservation(claudePath, content);
-          generatedFiles.push(path52.relative(this.config.projectPath, claudePath));
+          generatedFiles.push(path53.relative(this.config.projectPath, claudePath));
         }
         return generatedFiles;
       }
@@ -26359,8 +27008,8 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
         let pkgVersion = stats.version;
         let pkgName = pkg.name;
         try {
-          const pkgJsonPath = path52.join(pkg.path, "package.json");
-          const pkgJson = JSON.parse(await fs49.readFile(pkgJsonPath, "utf-8"));
+          const pkgJsonPath = path53.join(pkg.path, "package.json");
+          const pkgJson = JSON.parse(await fs50.readFile(pkgJsonPath, "utf-8"));
           pkgVersion = pkgJson.version || stats.version;
           pkgName = pkgJson.name || pkg.name;
         } catch {
@@ -26425,8 +27074,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 });
 
 // core/services/local-state-generator.ts
-import fs50 from "node:fs/promises";
-import path53 from "node:path";
+import fs51 from "node:fs/promises";
+import path54 from "node:path";
 var LOCAL_STATE_FILENAME, LocalStateGenerator, localStateGenerator;
 var init_local_state_generator = __esm({
   "core/services/local-state-generator.ts"() {
@@ -26441,17 +27090,17 @@ var init_local_state_generator = __esm({
        * Generate .prjct-state.md in the project root
        */
       async generate(projectPath, state) {
-        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path54.join(projectPath, LOCAL_STATE_FILENAME);
         const content = this.toMarkdown(state);
-        await fs50.writeFile(filePath, content, "utf-8");
+        await fs51.writeFile(filePath, content, "utf-8");
       }
       /**
        * Remove local state file
        */
       async remove(projectPath) {
-        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path54.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs50.unlink(filePath);
+          await fs51.unlink(filePath);
         } catch (error) {
           if (!isNotFoundError(error)) throw error;
         }
@@ -26460,9 +27109,9 @@ var init_local_state_generator = __esm({
        * Check if local state file exists
        */
       async exists(projectPath) {
-        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path54.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs50.access(filePath);
+          await fs51.access(filePath);
           return true;
         } catch {
           return false;
@@ -26541,11 +27190,11 @@ var init_local_state_generator = __esm({
 });
 
 // core/services/skill-lock.ts
-import fs51 from "node:fs/promises";
+import fs52 from "node:fs/promises";
 import os14 from "node:os";
-import path54 from "node:path";
+import path55 from "node:path";
 function getLockFilePath() {
-  return path54.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
+  return path55.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
 }
 function createEmptyLockFile() {
   return {
@@ -26556,7 +27205,7 @@ function createEmptyLockFile() {
 }
 async function read() {
   try {
-    const content = await fs51.readFile(getLockFilePath(), "utf-8");
+    const content = await fs52.readFile(getLockFilePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return createEmptyLockFile();
@@ -26564,9 +27213,9 @@ async function read() {
 }
 async function write(lockFile) {
   const lockPath = getLockFilePath();
-  await fs51.mkdir(path54.dirname(lockPath), { recursive: true });
+  await fs52.mkdir(path55.dirname(lockPath), { recursive: true });
   lockFile.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs51.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
+  await fs52.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
 }
 async function addEntry(entry) {
   const lockFile = await read();
@@ -26619,14 +27268,14 @@ var init_skill_lock = __esm({
 
 // core/services/skill-installer.ts
 import { exec as execCallback8 } from "node:child_process";
-import fs52 from "node:fs/promises";
+import fs53 from "node:fs/promises";
 import os15 from "node:os";
-import path55 from "node:path";
+import path56 from "node:path";
 import { promisify as promisify16 } from "node:util";
 import { glob } from "glob";
 function parseSource(source) {
   if (source.startsWith("./") || source.startsWith("/") || source.startsWith("~")) {
-    const resolvedPath = source.startsWith("~") ? path55.join(os15.homedir(), source.slice(1)) : path55.resolve(source);
+    const resolvedPath = source.startsWith("~") ? path56.join(os15.homedir(), source.slice(1)) : path56.resolve(source);
     return {
       type: "local",
       localPath: resolvedPath,
@@ -26664,22 +27313,22 @@ function parseSource(source) {
 async function discoverSkills(dir) {
   const skills = [];
   try {
-    const rootSkill = path55.join(dir, "SKILL.md");
-    await fs52.access(rootSkill);
-    const dirName = path55.basename(dir);
+    const rootSkill = path56.join(dir, "SKILL.md");
+    await fs53.access(rootSkill);
+    const dirName = path56.basename(dir);
     skills.push({ name: dirName, filePath: rootSkill });
   } catch {
   }
   const subdirSkills = await glob("*/SKILL.md", { cwd: dir, absolute: true });
   for (const filePath of subdirSkills) {
-    const name = path55.basename(path55.dirname(filePath));
+    const name = path56.basename(path56.dirname(filePath));
     if (!skills.some((s) => s.name === name)) {
       skills.push({ name, filePath });
     }
   }
   const nestedSkills = await glob("skills/*/SKILL.md", { cwd: dir, absolute: true });
   for (const filePath of nestedSkills) {
-    const name = path55.basename(path55.dirname(filePath));
+    const name = path56.basename(path56.dirname(filePath));
     if (!skills.some((s) => s.name === name)) {
       skills.push({ name, filePath });
     }
@@ -26715,16 +27364,16 @@ ${prjctBlock.join("\n")}
 ${content}`;
 }
 function getInstallDir() {
-  return path55.join(os15.homedir(), ".claude", "skills");
+  return path56.join(os15.homedir(), ".claude", "skills");
 }
 async function installSkillFile(sourcePath, name, source, sha) {
   const installDir = getInstallDir();
-  const targetDir = path55.join(installDir, name);
-  const targetPath = path55.join(targetDir, "SKILL.md");
-  const content = await fs52.readFile(sourcePath, "utf-8");
+  const targetDir = path56.join(installDir, name);
+  const targetPath = path56.join(targetDir, "SKILL.md");
+  const content = await fs53.readFile(sourcePath, "utf-8");
   const enrichedContent = injectSourceMetadata(content, source, sha);
-  await fs52.mkdir(targetDir, { recursive: true });
-  await fs52.writeFile(targetPath, enrichedContent, "utf-8");
+  await fs53.mkdir(targetDir, { recursive: true });
+  await fs53.writeFile(targetPath, enrichedContent, "utf-8");
   return {
     name,
     filePath: targetPath,
@@ -26741,7 +27390,7 @@ async function installFromGitHub(source) {
     );
     return result;
   }
-  const tmpDir = path55.join(os15.tmpdir(), `prjct-skill-${Date.now()}`);
+  const tmpDir = path56.join(os15.tmpdir(), `prjct-skill-${Date.now()}`);
   try {
     const cloneUrl = `https://github.com/${source.owner}/${source.repo}.git`;
     await exec15(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
@@ -26785,7 +27434,7 @@ async function installFromGitHub(source) {
     }
   } finally {
     try {
-      await fs52.rm(tmpDir, { recursive: true, force: true });
+      await fs53.rm(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -26795,14 +27444,14 @@ async function installFromLocal(source) {
   const result = { installed: [], skipped: [], errors: [] };
   const localPath = source.localPath;
   try {
-    await fs52.access(localPath);
+    await fs53.access(localPath);
   } catch {
     result.errors.push(`Local path not found: ${localPath}`);
     return result;
   }
-  const stat = await fs52.stat(localPath);
+  const stat = await fs53.stat(localPath);
   if (stat.isFile()) {
-    const name = path55.basename(path55.dirname(localPath));
+    const name = path56.basename(path56.dirname(localPath));
     try {
       const installed = await installSkillFile(localPath, name, source);
       const lockEntry = {
@@ -26842,14 +27491,14 @@ async function installFromLocal(source) {
 }
 async function remove(name) {
   const installDir = getInstallDir();
-  const subdirPath = path55.join(installDir, name);
+  const subdirPath = path56.join(installDir, name);
   try {
-    await fs52.rm(subdirPath, { recursive: true, force: true });
+    await fs53.rm(subdirPath, { recursive: true, force: true });
   } catch {
   }
-  const flatPath = path55.join(installDir, `${name}.md`);
+  const flatPath = path56.join(installDir, `${name}.md`);
   try {
-    await fs52.rm(flatPath, { force: true });
+    await fs53.rm(flatPath, { force: true });
   } catch {
   }
   return skillLock.removeEntry(name);
@@ -26897,8 +27546,8 @@ var init_skill_installer = __esm({
 });
 
 // core/services/stack-detector.ts
-import fs53 from "node:fs/promises";
-import path56 from "node:path";
+import fs54 from "node:fs/promises";
+import path57 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -27057,8 +27706,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path56.join(this.projectPath, "package.json");
-          const content = await fs53.readFile(pkgPath, "utf-8");
+          const pkgPath = path57.join(this.projectPath, "package.json");
+          const content = await fs54.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -27069,7 +27718,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs53.access(path56.join(this.projectPath, filename));
+          await fs54.access(path57.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -27081,8 +27730,8 @@ var init_stack_detector = __esm({
 
 // core/services/sync-verifier.ts
 import { exec as exec16 } from "node:child_process";
-import fs54 from "node:fs/promises";
-import path57 from "node:path";
+import fs55 from "node:fs/promises";
+import path58 from "node:path";
 import { promisify as promisify17 } from "node:util";
 var execAsync10, BUILTIN_CHECKS, SyncVerifier, syncVerifier;
 var init_sync_verifier = __esm({
@@ -27099,9 +27748,9 @@ var init_sync_verifier = __esm({
         const expected = ["context/CLAUDE.md"];
         const missing = [];
         for (const file of expected) {
-          const filePath = path57.join(globalPath, file);
+          const filePath = path58.join(globalPath, file);
           try {
-            await fs54.access(filePath);
+            await fs55.access(filePath);
           } catch {
             missing.push(file);
           }
@@ -27122,9 +27771,9 @@ var init_sync_verifier = __esm({
         const jsonFiles = ["storage/state.json"];
         const invalid = [];
         for (const file of jsonFiles) {
-          const filePath = path57.join(globalPath, file);
+          const filePath = path58.join(globalPath, file);
           try {
-            const content = await fs54.readFile(filePath, "utf-8");
+            const content = await fs55.readFile(filePath, "utf-8");
             JSON.parse(content);
           } catch (error) {
             if (!isNotFoundError(error)) {
@@ -27145,7 +27794,7 @@ var init_sync_verifier = __esm({
        */
       async noSensitiveData(globalPath) {
         const start = Date.now();
-        const contextDir = path57.join(globalPath, "context");
+        const contextDir = path58.join(globalPath, "context");
         const patterns = [
           /(?:api[_-]?key|apikey)\s*[:=]\s*['"][^'"]{10,}/i,
           /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{4,}/i,
@@ -27153,10 +27802,10 @@ var init_sync_verifier = __esm({
         ];
         const violations = [];
         try {
-          const files = await fs54.readdir(contextDir);
+          const files = await fs55.readdir(contextDir);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
-            const content = await fs54.readFile(path57.join(contextDir, file), "utf-8");
+            const content = await fs55.readFile(path58.join(contextDir, file), "utf-8");
             for (const pattern of patterns) {
               if (pattern.test(content)) {
                 violations.push(`${file}: potential sensitive data detected`);
@@ -27277,9 +27926,9 @@ var init_sync_verifier = __esm({
 
 // core/services/sync-service.ts
 import { exec as exec17 } from "node:child_process";
-import fs55 from "node:fs/promises";
+import fs56 from "node:fs/promises";
 import os16 from "node:os";
-import path58 from "node:path";
+import path59 from "node:path";
 import { promisify as promisify18 } from "node:util";
 var execAsync11, SyncService, syncService;
 var init_sync_service = __esm({
@@ -27543,7 +28192,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs55.mkdir(path58.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs56.mkdir(path59.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -27614,7 +28263,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path58.basename(this.projectPath),
+          name: path59.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -27631,8 +28280,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path58.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs55.readFile(pkgPath, "utf-8"));
+          const pkgPath = path59.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs56.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -27777,12 +28426,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path58.join(this.globalPath, "agents");
+        const agentsPath = path59.join(this.globalPath, "agents");
         try {
-          const files = await fs55.readdir(agentsPath);
+          const files = await fs56.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs55.unlink(path58.join(agentsPath, file));
+              await fs56.unlink(path59.join(agentsPath, file));
             }
           }
         } catch (error) {
@@ -27825,10 +28474,10 @@ var init_sync_service = __esm({
        * Reads the agents directory and returns metadata without regenerating files.
        */
       async loadExistingAgents() {
-        const agentsPath = path58.join(this.globalPath, "agents");
+        const agentsPath = path59.join(this.globalPath, "agents");
         const agents = [];
         try {
-          const files = await fs55.readdir(agentsPath);
+          const files = await fs56.readdir(agentsPath);
           const workflowNames = /* @__PURE__ */ new Set(["prjct-workflow", "prjct-planner", "prjct-shipper"]);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
@@ -27852,7 +28501,7 @@ var init_sync_service = __esm({
         let resolved = content;
         for (const match of matches) {
           const partialName = match[1];
-          const partialPath = path58.join(
+          const partialPath = path59.join(
             __dirname,
             "..",
             "..",
@@ -27861,7 +28510,7 @@ var init_sync_service = __esm({
             `${partialName}.md`
           );
           try {
-            const partialContent = await fs55.readFile(partialPath, "utf-8");
+            const partialContent = await fs56.readFile(partialPath, "utf-8");
             resolved = resolved.replace(match[0], partialContent.trim());
           } catch {
             resolved = resolved.replace(match[0], `<!-- partial "${partialName}" not found -->`);
@@ -27872,7 +28521,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path58.join(
+          const templatePath = path59.join(
             __dirname,
             "..",
             "..",
@@ -27881,7 +28530,7 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs55.readFile(templatePath, "utf-8");
+          content = await fs56.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
         } catch (error) {
           logger_default.debug("Workflow agent template not found, generating minimal", {
@@ -27890,12 +28539,12 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs55.writeFile(path58.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs56.writeFile(path59.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path58.join(
+          const templatePath = path59.join(
             __dirname,
             "..",
             "..",
@@ -27904,7 +28553,7 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs55.readFile(templatePath, "utf-8");
+          content = await fs56.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
@@ -27916,7 +28565,7 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs55.writeFile(path58.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs56.writeFile(path59.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -27984,8 +28633,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]))
         };
-        fs55.writeFile(
-          path58.join(this.globalPath, "config", "skills.json"),
+        fs56.writeFile(
+          path59.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch((error) => {
@@ -28003,7 +28652,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       async autoInstallSkills(agents) {
         const results = [];
         try {
-          const mappingsPath = path58.join(
+          const mappingsPath = path59.join(
             __dirname,
             "..",
             "..",
@@ -28011,7 +28660,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
             "config",
             "skill-mappings.json"
           );
-          const mappingsContent = await fs55.readFile(mappingsPath, "utf-8");
+          const mappingsContent = await fs56.readFile(mappingsPath, "utf-8");
           const mappings = JSON.parse(mappingsContent);
           const agentToSkillMap = mappings.agentToSkillMap || {};
           const packagesToInstall = [];
@@ -28024,18 +28673,18 @@ You are the ${name} expert for this project. Apply best practices for the detect
             }
           }
           if (packagesToInstall.length === 0) return results;
-          const skillsDir = path58.join(os16.homedir(), ".claude", "skills");
+          const skillsDir = path59.join(os16.homedir(), ".claude", "skills");
           for (const { pkg, agent } of packagesToInstall) {
             const skillName = pkg.split("/").pop() || pkg;
-            const subdirPath = path58.join(skillsDir, skillName, "SKILL.md");
-            const flatPath = path58.join(skillsDir, `${skillName}.md`);
+            const subdirPath = path59.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path59.join(skillsDir, `${skillName}.md`);
             let alreadyInstalled = false;
             try {
-              await fs55.access(subdirPath);
+              await fs56.access(subdirPath);
               alreadyInstalled = true;
             } catch {
               try {
-                await fs55.access(flatPath);
+                await fs56.access(flatPath);
                 alreadyInstalled = true;
               } catch {
               }
@@ -28087,10 +28736,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path58.join(this.globalPath, "project.json");
+        const projectJsonPath = path59.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs55.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs56.readFile(projectJsonPath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing project.json", {
             path: projectJsonPath,
@@ -28116,16 +28765,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 fs55.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs56.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path58.join(this.globalPath, "storage", "state.json");
+        const statePath = path59.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs55.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs56.readFile(statePath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing state.json", { path: statePath, error: getErrorMessage(error) });
         }
@@ -28153,7 +28802,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 fs55.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs56.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
         try {
           await localStateGenerator.generate(
             this.projectPath,
@@ -28167,7 +28816,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path58.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path59.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: getTimestamp(),
           action: "sync",
@@ -28176,7 +28825,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs55.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs56.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -28196,8 +28845,8 @@ 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 = path58.join(this.globalPath, file);
-            const content = await fs55.readFile(filePath, "utf-8");
+            const filePath = path59.join(this.globalPath, file);
+            const content = await fs56.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Context file not found for metrics", { file, error: getErrorMessage(error) });
@@ -28205,8 +28854,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
         }
         for (const agent of agents) {
           try {
-            const agentPath = path58.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs55.readFile(agentPath, "utf-8");
+            const agentPath = path59.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs56.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Agent file not found for metrics", {
@@ -28302,7 +28951,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs55.access(path58.join(this.projectPath, filename));
+          await fs56.access(path59.join(this.projectPath, filename));
           return true;
         } catch (error) {
           logger_default.debug("File not found", { filename, error: getErrorMessage(error) });
@@ -28311,8 +28960,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path58.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs55.readFile(pkgPath, "utf-8"));
+          const pkgPath = path59.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs56.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch (error) {
           logger_default.debug("Failed to read CLI version", { error: getErrorMessage(error) });
@@ -28473,22 +29122,22 @@ __export(uninstall_exports, {
   uninstall: () => uninstall
 });
 import { execSync as execSync3 } from "node:child_process";
-import fs56 from "node:fs/promises";
+import fs57 from "node:fs/promises";
 import os17 from "node:os";
-import path59 from "node:path";
+import path60 from "node:path";
 import readline2 from "node:readline";
 import chalk12 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs56.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs57.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path59.join(dirPath, entry.name);
+      const entryPath = path60.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs56.stat(entryPath);
+          const stats = await fs57.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -28507,7 +29156,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs56.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs57.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -28540,7 +29189,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = await fileExists(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path59.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path60.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -28550,12 +29199,12 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path59.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path60.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = await fileExists(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
     try {
-      const content = await fs56.readFile(claudeMdPath, "utf-8");
+      const content = await fs57.readFile(claudeMdPath, "utf-8");
       hasPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -28584,7 +29233,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path59.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path60.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = await fileExists(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -28600,12 +29249,12 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path59.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path60.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = await fileExists(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
     try {
-      const content = await fs56.readFile(geminiMdPath, "utf-8");
+      const content = await fs57.readFile(geminiMdPath, "utf-8");
       hasGeminiPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -28622,7 +29271,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs56.readFile(filePath, "utf-8");
+    const content = await fs57.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -28631,9 +29280,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 fs56.unlink(filePath);
+      await fs57.unlink(filePath);
     } else {
-      await fs56.writeFile(filePath, `${newContent}
+      await fs57.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -28644,12 +29293,12 @@ async function removePrjctSection(filePath) {
 async function createBackup3() {
   const homeDir = os17.homedir();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
-  const backupDir = path59.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path60.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs56.mkdir(backupDir, { recursive: true });
+    await fs57.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (await fileExists(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path59.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path60.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -28657,15 +29306,15 @@ async function createBackup3() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs56.mkdir(dest, { recursive: true });
-  const entries = await fs56.readdir(src, { withFileTypes: true });
+  await fs57.mkdir(dest, { recursive: true });
+  const entries = await fs57.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path59.join(src, entry.name);
-    const destPath = path59.join(dest, entry.name);
+    const srcPath = path60.join(src, entry.name);
+    const destPath = path60.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs56.copyFile(srcPath, destPath);
+      await fs57.copyFile(srcPath, destPath);
     }
   }
 }
@@ -28681,10 +29330,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs56.rm(item.path, { recursive: true, force: true });
+        await fs57.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs56.unlink(item.path);
+        await fs57.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -28861,7 +29510,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path60 from "node:path";
+import path61 from "node:path";
 import chalk13 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -29082,7 +29731,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: ${path60.basename(this.projectPath)}`));
+        console.log(chalk13.dim(`   Project: ${path61.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("");
@@ -29815,9 +30464,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync4 } from "node:child_process";
-import fs57 from "node:fs/promises";
+import fs58 from "node:fs/promises";
 import os18 from "node:os";
-import path61 from "node:path";
+import path62 from "node:path";
 import chalk15 from "chalk";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
@@ -29956,12 +30605,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path61.join(os18.homedir(), ".gemini", "commands");
-    const routerSource = path61.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
-    const routerDest = path61.join(geminiCommandsDir, "p.toml");
-    await fs57.mkdir(geminiCommandsDir, { recursive: true });
+    const geminiCommandsDir = path62.join(os18.homedir(), ".gemini", "commands");
+    const routerSource = path62.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
+    const routerDest = path62.join(geminiCommandsDir, "p.toml");
+    await fs58.mkdir(geminiCommandsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs57.copyFile(routerSource, routerDest);
+      await fs58.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -29972,15 +30621,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path61.join(os18.homedir(), ".gemini");
-    const globalConfigPath = path61.join(geminiDir, "GEMINI.md");
-    const templatePath = path61.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
-    await fs57.mkdir(geminiDir, { recursive: true });
-    const templateContent = await fs57.readFile(templatePath, "utf-8");
+    const geminiDir = path62.join(os18.homedir(), ".gemini");
+    const globalConfigPath = path62.join(geminiDir, "GEMINI.md");
+    const templatePath = path62.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
+    await fs58.mkdir(geminiDir, { recursive: true });
+    const templateContent = await fs58.readFile(templatePath, "utf-8");
     let existingContent = "";
     let configExists = false;
     try {
-      existingContent = await fs57.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs58.readFile(globalConfigPath, "utf-8");
       configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -29990,7 +30639,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!configExists) {
-      await fs57.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs58.writeFile(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -30000,7 +30649,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      await fs57.writeFile(globalConfigPath, updatedContent2, "utf-8");
+      await fs58.writeFile(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -30012,7 +30661,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    await fs57.writeFile(globalConfigPath, updatedContent, "utf-8");
+    await fs58.writeFile(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     logger_default.warn(`Gemini config warning: ${getErrorMessage2(error)}`);
@@ -30021,18 +30670,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path61.join(os18.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = path61.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = path61.join(prjctSkillDir, "SKILL.md");
-    const templatePath = path61.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
-    await fs57.mkdir(prjctSkillDir, { recursive: true });
+    const antigravitySkillsDir = path62.join(os18.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path62.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path62.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path62.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
+    await fs58.mkdir(prjctSkillDir, { recursive: true });
     const skillExists = await fileExists(skillMdPath);
     if (!await fileExists(templatePath)) {
       logger_default.warn("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = await fs57.readFile(templatePath, "utf-8");
-    await fs57.writeFile(skillMdPath, templateContent, "utf-8");
+    const templateContent = await fs58.readFile(templatePath, "utf-8");
+    await fs58.writeFile(skillMdPath, templateContent, "utf-8");
     return { success: true, action: skillExists ? "updated" : "created" };
   } catch (error) {
     logger_default.warn(`Antigravity skill warning: ${getErrorMessage2(error)}`);
@@ -30051,24 +30700,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = path61.join(projectRoot, ".cursor");
-    const rulesDir = path61.join(cursorDir, "rules");
-    const commandsDir = path61.join(cursorDir, "commands");
-    const routerMdcDest = path61.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = path61.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = path61.join(PACKAGE_ROOT, "templates", "cursor", "commands");
-    await fs57.mkdir(rulesDir, { recursive: true });
-    await fs57.mkdir(commandsDir, { recursive: true });
+    const cursorDir = path62.join(projectRoot, ".cursor");
+    const rulesDir = path62.join(cursorDir, "rules");
+    const commandsDir = path62.join(cursorDir, "commands");
+    const routerMdcDest = path62.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path62.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path62.join(PACKAGE_ROOT, "templates", "cursor", "commands");
+    await fs58.mkdir(rulesDir, { recursive: true });
+    await fs58.mkdir(commandsDir, { recursive: true });
     if (await fileExists(routerMdcSource)) {
-      await fs57.copyFile(routerMdcSource, routerMdcDest);
+      await fs58.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
     if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await fs57.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
+      const commandFiles = (await fs58.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path61.join(cursorCommandsSource, file);
-        const dest = path61.join(commandsDir, file);
-        await fs57.copyFile(src, dest);
+        const src = path62.join(cursorCommandsSource, file);
+        const dest = path62.join(commandsDir, file);
+        await fs58.copyFile(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -30082,7 +30731,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path61.join(projectRoot, ".gitignore");
+    const gitignorePath = path62.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -30097,7 +30746,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs57.readFile(gitignorePath, "utf-8");
+      content = await fs58.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -30112,7 +30761,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs57.writeFile(gitignorePath, newContent, "utf-8");
+    await fs58.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -30120,11 +30769,11 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasCursorProject(projectRoot) {
-  return await fileExists(path61.join(projectRoot, ".cursor"));
+  return await fileExists(path62.join(projectRoot, ".cursor"));
 }
 async function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path61.join(projectRoot, ".cursor");
-  const routerPath = path61.join(cursorDir, "rules", "prjct.mdc");
+  const cursorDir = path62.join(projectRoot, ".cursor");
+  const routerPath = path62.join(cursorDir, "rules", "prjct.mdc");
   return await fileExists(cursorDir) && !await fileExists(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
@@ -30135,26 +30784,26 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = path61.join(projectRoot, ".windsurf");
-    const rulesDir = path61.join(windsurfDir, "rules");
-    const workflowsDir = path61.join(windsurfDir, "workflows");
-    const routerDest = path61.join(rulesDir, "prjct.md");
-    const routerSource = path61.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = path61.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
-    await fs57.mkdir(rulesDir, { recursive: true });
-    await fs57.mkdir(workflowsDir, { recursive: true });
+    const windsurfDir = path62.join(projectRoot, ".windsurf");
+    const rulesDir = path62.join(windsurfDir, "rules");
+    const workflowsDir = path62.join(windsurfDir, "workflows");
+    const routerDest = path62.join(rulesDir, "prjct.md");
+    const routerSource = path62.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path62.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
+    await fs58.mkdir(rulesDir, { recursive: true });
+    await fs58.mkdir(workflowsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs57.copyFile(routerSource, routerDest);
+      await fs58.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
     if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await fs57.readdir(windsurfWorkflowsSource)).filter(
+      const workflowFiles = (await fs58.readdir(windsurfWorkflowsSource)).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of workflowFiles) {
-        const src = path61.join(windsurfWorkflowsSource, file);
-        const dest = path61.join(workflowsDir, file);
-        await fs57.copyFile(src, dest);
+        const src = path62.join(windsurfWorkflowsSource, file);
+        const dest = path62.join(workflowsDir, file);
+        await fs58.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -30168,7 +30817,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path61.join(projectRoot, ".gitignore");
+    const gitignorePath = path62.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -30183,7 +30832,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs57.readFile(gitignorePath, "utf-8");
+      content = await fs58.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -30198,7 +30847,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs57.writeFile(gitignorePath, newContent, "utf-8");
+    await fs58.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -30206,32 +30855,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasWindsurfProject(projectRoot) {
-  return await fileExists(path61.join(projectRoot, ".windsurf"));
+  return await fileExists(path62.join(projectRoot, ".windsurf"));
 }
 async function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path61.join(projectRoot, ".windsurf");
-  const routerPath = path61.join(windsurfDir, "rules", "prjct.md");
+  const windsurfDir = path62.join(projectRoot, ".windsurf");
+  const routerPath = path62.join(windsurfDir, "rules", "prjct.md");
   return await fileExists(windsurfDir) && !await fileExists(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path61.join(os18.homedir(), ".prjct-cli", "projects");
+    const projectsDir = path62.join(os18.homedir(), ".prjct-cli", "projects");
     if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = (await fs57.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await fs58.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path61.join(projectsDir, projectId, "project.json");
+      const projectJsonPath = path62.join(projectsDir, projectId, "project.json");
       if (!await fileExists(projectJsonPath)) {
         continue;
       }
       try {
-        const content = await fs57.readFile(projectJsonPath, "utf8");
+        const content = await fs58.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          await fs57.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await fs58.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -30253,7 +30902,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
   if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(await fs57.readFile(settingsPath, "utf8"));
+      settings = JSON.parse(await fs58.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -30261,42 +30910,42 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  await fs57.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await fs58.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path61.join(os18.homedir(), ".claude");
-    const settingsPath = path61.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = path61.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path61.join(os18.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = path61.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = path61.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = path61.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = path61.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = path61.join(prjctStatusLineDir, "config.json");
-    const assetsDir = path61.join(PACKAGE_ROOT, "assets", "statusline");
-    const sourceScript = path61.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = path61.join(assetsDir, "themes");
-    const sourceLibDir = path61.join(assetsDir, "lib");
-    const sourceComponentsDir = path61.join(assetsDir, "components");
-    const sourceConfigPath = path61.join(assetsDir, "default-config.json");
+    const claudeDir = path62.join(os18.homedir(), ".claude");
+    const settingsPath = path62.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path62.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path62.join(os18.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path62.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path62.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path62.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path62.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path62.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path62.join(PACKAGE_ROOT, "assets", "statusline");
+    const sourceScript = path62.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path62.join(assetsDir, "themes");
+    const sourceLibDir = path62.join(assetsDir, "lib");
+    const sourceComponentsDir = path62.join(assetsDir, "components");
+    const sourceConfigPath = path62.join(assetsDir, "default-config.json");
     if (!await fileExists(claudeDir)) {
-      await fs57.mkdir(claudeDir, { recursive: true });
+      await fs58.mkdir(claudeDir, { recursive: true });
     }
     if (!await fileExists(prjctStatusLineDir)) {
-      await fs57.mkdir(prjctStatusLineDir, { recursive: true });
+      await fs58.mkdir(prjctStatusLineDir, { recursive: true });
     }
     if (!await fileExists(prjctThemesDir)) {
-      await fs57.mkdir(prjctThemesDir, { recursive: true });
+      await fs58.mkdir(prjctThemesDir, { recursive: true });
     }
     if (!await fileExists(prjctLibDir)) {
-      await fs57.mkdir(prjctLibDir, { recursive: true });
+      await fs58.mkdir(prjctLibDir, { recursive: true });
     }
     if (!await fileExists(prjctComponentsDir)) {
-      await fs57.mkdir(prjctComponentsDir, { recursive: true });
+      await fs58.mkdir(prjctComponentsDir, { recursive: true });
     }
     if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await fs57.readFile(prjctStatusLinePath, "utf8");
+      const existingContent = await fs58.readFile(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -30304,7 +30953,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          await fs57.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await fs58.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         await installStatusLineModules(sourceLibDir, prjctLibDir);
         await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -30314,21 +30963,21 @@ async function installStatusLine() {
       }
     }
     if (await fileExists(sourceScript)) {
-      let scriptContent = await fs57.readFile(sourceScript, "utf8");
+      let scriptContent = await fs58.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await fs57.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs58.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
       await installStatusLineModules(sourceLibDir, prjctLibDir);
       await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
       if (await fileExists(sourceThemeDir)) {
-        const themes = await fs57.readdir(sourceThemeDir);
+        const themes = await fs58.readdir(sourceThemeDir);
         for (const theme of themes) {
-          const src = path61.join(sourceThemeDir, theme);
-          const dest = path61.join(prjctThemesDir, theme);
-          await fs57.copyFile(src, dest);
+          const src = path62.join(sourceThemeDir, theme);
+          const dest = path62.join(prjctThemesDir, theme);
+          await fs58.copyFile(src, dest);
         }
       }
       if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await fs57.copyFile(sourceConfigPath, prjctConfigPath);
+        await fs58.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -30363,7 +31012,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      await fs57.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs58.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -30375,10 +31024,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path61.join(os18.homedir(), ".claude");
-    const mcpConfigPath = path61.join(claudeDir, "mcp.json");
+    const claudeDir = path62.join(os18.homedir(), ".claude");
+    const mcpConfigPath = path62.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
-      await fs57.mkdir(claudeDir, { recursive: true });
+      await fs58.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -30389,16 +31038,16 @@ async function installContext7MCP() {
       }
     };
     if (await fileExists(mcpConfigPath)) {
-      const existingContent = await fs57.readFile(mcpConfigPath, "utf-8");
+      const existingContent = await fs58.readFile(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      await fs57.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await fs58.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      await fs57.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      await fs58.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     logger_default.warn(`Context7 MCP setup warning: ${getErrorMessage2(error)}`);
@@ -30408,34 +31057,34 @@ async function installStatusLineModules(sourceDir, destDir) {
   if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = await fs57.readdir(sourceDir);
+  const files = await fs58.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path61.join(sourceDir, file);
-      const dest = path61.join(destDir, file);
-      await fs57.copyFile(src, dest);
-      await fs57.chmod(dest, 493);
+      const src = path62.join(sourceDir, file);
+      const dest = path62.join(destDir, file);
+      await fs58.copyFile(src, dest);
+      await fs58.chmod(dest, 493);
     }
   }
 }
 async function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
     if (await fileExists(linkPath)) {
-      const stats = await fs57.lstat(linkPath);
+      const stats = await fs58.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = await fs57.readlink(linkPath);
+        const existingTarget = await fs58.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      await fs57.unlink(linkPath);
+      await fs58.unlink(linkPath);
     }
-    await fs57.symlink(targetPath, linkPath);
+    await fs58.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
       if (await fileExists(targetPath)) {
-        await fs57.copyFile(targetPath, linkPath);
-        await fs57.chmod(linkPath, 493);
+        await fs58.copyFile(targetPath, linkPath);
+        await fs58.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -30850,7 +31499,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path62 from "node:path";
+import path63 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -30877,7 +31526,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path62.basename(projectPath);
+          const projectName = path63.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -31129,8 +31778,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs58 from "node:fs/promises";
-import path63 from "node:path";
+import fs59 from "node:fs/promises";
+import path64 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -31256,8 +31905,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path63.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs58.readFile(analysisPath, "utf-8");
+          const analysisPath = path64.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs59.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -31276,7 +31925,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path64 from "node:path";
+import path65 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -31292,7 +31941,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_exports.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path64.basename(filePath));
+          results.rotated.push(path65.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -31399,7 +32048,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path65 from "node:path";
+import path66 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -31411,7 +32060,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 = path65.join(
+    const designsPath = path66.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -31451,7 +32100,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path65.join(designsPath, designFileName);
+    const designFilePath = path66.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -31476,7 +32125,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path66 from "node:path";
+import path67 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -31528,7 +32177,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path66.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path67.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync5 } = await import("node:child_process");
     try {
@@ -31546,7 +32195,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path66.join(snapshotsPath, "history.json");
+      const snapshotFile = path67.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -31586,8 +32235,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path66.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path66.join(snapshotsPath, "history.json");
+    const snapshotsPath = path67.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path67.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -31646,8 +32295,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path66.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path66.join(snapshotsPath, "history.json");
+    const snapshotsPath = path67.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path67.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -31850,8 +32499,8 @@ ${chalk16.cyan("Performance Report")} ${chalk16.dim(`(last ${days} days)`)}`);
 });
 
 // core/commands/setup.ts
-import fs59 from "node:fs/promises";
-import path67 from "node:path";
+import fs60 from "node:fs/promises";
+import path68 from "node:path";
 import chalk17 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -31980,7 +32629,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path67.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path68.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -32038,11 +32687,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          await fs59.writeFile(statusLinePath, scriptContent, { mode: 493 });
+          await fs60.writeFile(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
           if (await fileExists(settingsPath)) {
             try {
-              settings = JSON.parse(await fs59.readFile(settingsPath, "utf8"));
+              settings = JSON.parse(await fs60.readFile(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -32050,7 +32699,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          await fs59.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+          await fs60.writeFile(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: getErrorMessage2(error) };
@@ -32106,18 +32755,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path68 from "node:path";
+import path69 from "node:path";
 async function detectPackageManager(projectPath, pkg) {
   const declared = pkg?.packageManager?.trim().toLowerCase();
   if (declared?.startsWith("pnpm@")) return "pnpm";
   if (declared?.startsWith("yarn@")) return "yarn";
   if (declared?.startsWith("bun@")) return "bun";
   if (declared?.startsWith("npm@")) return "npm";
-  if (await fileExists2(path68.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists2(path68.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists2(path68.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists2(path68.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists2(path68.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists2(path69.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists2(path69.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists2(path69.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists2(path69.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists2(path69.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -32133,7 +32782,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path68.join(projectPath, "package.json");
+  const pkgPath = path69.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -32150,27 +32799,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists2(path68.join(projectPath, "pytest.ini"))) {
+  if (await fileExists2(path69.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path68.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path69.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists2(path68.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists2(path69.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists2(path68.join(projectPath, "go.mod"))) {
+  if (await fileExists2(path69.join(projectPath, "go.mod"))) {
     return { stack: "go", test: { tool: "go", command: "go test ./..." } };
   }
   const files = await listFiles(projectPath);
   if (files.some((f) => f.endsWith(".sln") || f.endsWith(".csproj") || f.endsWith(".fsproj"))) {
     return { stack: "dotnet", test: { tool: "dotnet", command: "dotnet test" } };
   }
-  if (await fileExists2(path68.join(projectPath, "pom.xml"))) {
+  if (await fileExists2(path69.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists2(path68.join(projectPath, "gradlew")) && (await fileExists2(path68.join(projectPath, "build.gradle")) || await fileExists2(path68.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists2(path69.join(projectPath, "gradlew")) && (await fileExists2(path69.join(projectPath, "build.gradle")) || await fileExists2(path69.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -32345,7 +32994,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path69 from "node:path";
+import path70 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -32491,7 +33140,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path69.join(projectPath, "package.json");
+          const pkgPath = path70.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);
@@ -32513,7 +33162,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path69.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path70.join(projectPath, "CHANGELOG.md");
           const changelog = await file_helper_exports.readFile(changelogPath, "# Changelog\n\n");
           const entry = `## [${version}] - ${date_helper_exports.formatDate(/* @__PURE__ */ new Date())}
 
@@ -33557,11 +34206,11 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs60 from "node:fs/promises";
+import fs61 from "node:fs/promises";
 import os19 from "node:os";
-import path70 from "node:path";
+import path71 from "node:path";
 function getCredentialsPath(projectId) {
-  return path70.join(os19.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path71.join(os19.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
@@ -33569,7 +34218,7 @@ async function getProjectCredentials(projectId) {
     return {};
   }
   try {
-    return JSON.parse(await fs60.readFile(credPath, "utf-8"));
+    return JSON.parse(await fs61.readFile(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", getErrorMessage2(error));
     return {};
@@ -34241,7 +34890,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.19.0",
+      version: "1.21.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -34348,7 +34997,7 @@ var require_package = __commonJS({
 // core/index.ts
 var core_exports = {};
 import os20 from "node:os";
-import path71 from "node:path";
+import path72 from "node:path";
 import chalk20 from "chalk";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
@@ -34457,7 +35106,10 @@ async function main() {
           full: options.full === true
         }), "sync"),
         seal: /* @__PURE__ */ __name(() => commands.seal(process.cwd(), { json: options.json === true }), "seal"),
-        verify: /* @__PURE__ */ __name(() => commands.verify(process.cwd(), { json: options.json === true }), "verify"),
+        verify: /* @__PURE__ */ __name(() => commands.verify(process.cwd(), {
+          json: options.json === true,
+          semantic: options.semantic === true
+        }), "verify"),
         start: /* @__PURE__ */ __name(() => commands.start(), "start"),
         // Context (for Claude templates)
         context: /* @__PURE__ */ __name((p) => commands.context(p), "context")
@@ -34562,13 +35214,13 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 async function displayVersion(version) {
   const detection = await detectAllProviders();
-  const claudeCommandPath = path71.join(os20.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path71.join(os20.homedir(), ".gemini", "commands", "p.toml");
+  const claudeCommandPath = path72.join(os20.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path72.join(os20.homedir(), ".gemini", "commands", "p.toml");
   const [claudeConfigured, geminiConfigured, cursorConfigured, cursorExists] = await Promise.all([
     fileExists(claudeCommandPath),
     fileExists(geminiCommandPath),
-    fileExists(path71.join(process.cwd(), ".cursor", "commands", "sync.md")),
-    fileExists(path71.join(process.cwd(), ".cursor"))
+    fileExists(path72.join(process.cwd(), ".cursor", "commands", "sync.md")),
+    fileExists(path72.join(process.cwd(), ".cursor"))
   ]);
   const antigravityDetection = await detectAntigravity();
   console.log(`
@@ -34707,7 +35359,7 @@ init_ai_provider();
 init_config_manager();
 init_editors_config();
 import os21 from "node:os";
-import path72 from "node:path";
+import path73 from "node:path";
 import chalk21 from "chalk";
 
 // core/server/server.ts
@@ -35528,13 +36180,13 @@ async function checkRoutersInstalled() {
   const home = os21.homedir();
   const detection = await detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path72.join(home, ".claude", "commands", "p.md");
+    const claudeRouter = path73.join(home, ".claude", "commands", "p.md");
     if (!await fileExists(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path72.join(home, ".gemini", "commands", "p.toml");
+    const geminiRouter = path73.join(home, ".gemini", "commands", "p.toml");
     if (!await fileExists(geminiRouter)) {
       return false;
     }
@@ -35675,7 +36327,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path72.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path73.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -35702,12 +36354,12 @@ if (args[0] === "start" || args[0] === "setup") {
     windsurfDetected,
     windsurfConfigured
   ] = await Promise.all([
-    fileExists(path72.join(home, ".claude", "commands", "p.md")),
-    fileExists(path72.join(home, ".gemini", "commands", "p.toml")),
-    fileExists(path72.join(cwd, ".cursor")),
-    fileExists(path72.join(cwd, ".cursor", "rules", "prjct.mdc")),
-    fileExists(path72.join(cwd, ".windsurf")),
-    fileExists(path72.join(cwd, ".windsurf", "rules", "prjct.md"))
+    fileExists(path73.join(home, ".claude", "commands", "p.md")),
+    fileExists(path73.join(home, ".gemini", "commands", "p.toml")),
+    fileExists(path73.join(cwd, ".cursor")),
+    fileExists(path73.join(cwd, ".cursor", "rules", "prjct.mdc")),
+    fileExists(path73.join(cwd, ".windsurf")),
+    fileExists(path73.join(cwd, ".windsurf", "rules", "prjct.md"))
   ]);
   console.log(`
 ${chalk21.cyan("p/")} prjct v${VERSION}
@@ -35746,7 +36398,7 @@ ${chalk21.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
 ${chalk21.cyan("https://prjct.app")}
 `);
 } else {
-  const configPath = path72.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path73.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = await checkRoutersInstalled();
   if (!await fileExists(configPath) || !routersInstalled) {
     console.log(`