prjct-cli 1.16.0 → 1.17.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) => (path70) => {
-  var fn = map[path70];
+var __glob = (map) => (path72) => {
+  var fn = map[path72];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path70);
+  throw new Error("Module not found in bundle: " + path72);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -4051,7 +4051,7 @@ var init_cache = __esm({
 import { Database } from "bun:sqlite";
 import fs15 from "node:fs";
 import path14 from "node:path";
-var migrations, PrjctDatabase, prjctDb;
+var migrations, PrjctDatabase, prjctDb, database_default;
 var init_database = __esm({
   "core/storage/database.ts"() {
     "use strict";
@@ -4482,6 +4482,7 @@ var init_database = __esm({
       }
     };
     prjctDb = new PrjctDatabase();
+    database_default = prjctDb;
   }
 });
 
@@ -6575,11 +6576,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs58 = await import("node:fs/promises");
-  const path70 = await import("node:path");
-  const fullPath = path70.isAbsolute(filePath) ? filePath : path70.join(projectPath, filePath);
+  const fs60 = await import("node:fs/promises");
+  const path72 = await import("node:path");
+  const fullPath = path72.isAbsolute(filePath) ? filePath : path72.join(projectPath, filePath);
   try {
-    const stat = await fs58.stat(fullPath);
+    const stat = await fs60.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -6646,11 +6647,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs58 = await import("node:fs/promises");
-  const path70 = await import("node:path");
-  const fullPath = path70.isAbsolute(targetPath) ? targetPath : path70.join(projectPath, targetPath);
+  const fs60 = await import("node:fs/promises");
+  const path72 = await import("node:path");
+  const fullPath = path72.isAbsolute(targetPath) ? targetPath : path72.join(projectPath, targetPath);
   try {
-    const stat = await fs58.stat(fullPath);
+    const stat = await fs60.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -21767,16 +21768,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs58 = await import("node:fs/promises");
-        const path70 = await import("node:path");
+        const fs60 = await import("node:fs/promises");
+        const path72 = await import("node:path");
         try {
-          const files = await fs58.readdir(this.projectPath);
+          const files = await fs60.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 = path70.join(this.projectPath, "package.json");
-            const pkgContent = await fs58.readFile(pkgPath, "utf-8");
+            const pkgPath = path72.join(this.projectPath, "package.json");
+            const pkgContent = await fs60.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -21812,32 +21813,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs58 = await import("node:fs/promises");
-        const path70 = await import("node:path");
+        const fs60 = await import("node:fs/promises");
+        const path72 = await import("node:path");
         const os22 = await import("node:os");
         const agents = [];
         try {
-          await fs58.access(path70.join(os22.homedir(), ".claude"));
+          await fs60.access(path72.join(os22.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs58.access(path70.join(this.projectPath, ".cursorrules"));
+          await fs60.access(path72.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs58.access(path70.join(this.projectPath, ".windsurfrules"));
+          await fs60.access(path72.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs58.access(path70.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs60.access(path72.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs58.access(path70.join(os22.homedir(), ".gemini"));
+          await fs60.access(path72.join(os22.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -21847,17 +21848,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs58 = await import("node:fs/promises");
-        const path70 = await import("node:path");
+        const fs60 = await import("node:fs/promises");
+        const path72 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs58.readdir(this.projectPath);
+          const files = await fs60.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path70.join(this.projectPath, "package.json");
-            const pkgContent = await fs58.readFile(pkgPath, "utf-8");
+            const pkgPath = path72.join(this.projectPath, "package.json");
+            const pkgContent = await fs60.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -24082,8 +24083,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path45.join(globalPath2, "planning", "specs");
             try {
-              const fs58 = await import("node:fs/promises");
-              const files = await fs58.readdir(specsPath2);
+              const fs60 = await import("node:fs/promises");
+              const files = await fs60.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -25010,9 +25011,518 @@ var init_ai_tools = __esm({
   }
 });
 
-// core/services/context-generator.ts
+// core/domain/bm25.ts
 import fs46 from "node:fs/promises";
 import path49 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);
+}
+function tokenizeFile(content, filePath) {
+  const tokens = [];
+  const pathParts = filePath.replace(/\.[^.]+$/, "").split(/[/\\]/).filter(Boolean);
+  for (const part of pathParts) {
+    tokens.push(...splitIdentifier(part));
+  }
+  const exportPatterns = [
+    /export\s+(?:async\s+)?function\s+(\w+)/g,
+    /export\s+class\s+(\w+)/g,
+    /export\s+interface\s+(\w+)/g,
+    /export\s+type\s+(\w+)/g,
+    /export\s+(?:const|let|var)\s+(\w+)/g,
+    /export\s+default\s+(?:class|function)\s+(\w+)/g
+  ];
+  for (const pattern of exportPatterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      if (match[1]) {
+        tokens.push(...splitIdentifier(match[1]));
+      }
+    }
+  }
+  const declPatterns = [
+    /(?:async\s+)?function\s+(\w+)/g,
+    /class\s+(\w+)/g,
+    /interface\s+(\w+)/g,
+    /type\s+(\w+)\s*=/g
+  ];
+  for (const pattern of declPatterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      if (match[1]) {
+        tokens.push(...splitIdentifier(match[1]));
+      }
+    }
+  }
+  const importPattern = /(?:from|import)\s+['"]([^'"]+)['"]/g;
+  let importMatch;
+  while ((importMatch = importPattern.exec(content)) !== null) {
+    const source = importMatch[1];
+    if (source.startsWith(".") || source.startsWith("@/")) {
+      tokens.push(...splitIdentifier(source));
+    } else {
+      const pkgName = source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+      tokens.push(...splitIdentifier(pkgName));
+    }
+  }
+  const singleLineComments = /\/\/\s*(.+)/g;
+  let commentMatch;
+  while ((commentMatch = singleLineComments.exec(content)) !== null) {
+    const words = commentMatch[1].toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    tokens.push(...words);
+  }
+  const multiLineComments = /\/\*\*?([\s\S]*?)\*\//g;
+  let multiMatch;
+  while ((multiMatch = multiLineComments.exec(content)) !== null) {
+    const words = multiMatch[1].replace(/@\w+/g, "").replace(/\*/g, "").toLowerCase().split(/\s+/).filter((w) => w.length > 2 && /^[a-z]+$/.test(w));
+    tokens.push(...words);
+  }
+  return tokens.filter((t) => t.length > 1 && !STOP_WORDS.has(t) && /^[a-z][a-z0-9]*$/.test(t));
+}
+async function listFiles2(dir, projectPath) {
+  const files = [];
+  const entries = await fs46.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const fullPath = path49.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles2(fullPath, projectPath));
+    } else if (entry.isFile()) {
+      const ext = path49.extname(entry.name).toLowerCase();
+      if (INDEXABLE_EXTENSIONS.has(ext)) {
+        files.push(path49.relative(projectPath, fullPath));
+      }
+    }
+  }
+  return files;
+}
+async function buildIndex(projectPath) {
+  const files = await listFiles2(projectPath, projectPath);
+  const documents = {};
+  const invertedIndex = {};
+  let totalLength = 0;
+  const BATCH_SIZE = 50;
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map(async (filePath) => {
+        try {
+          const content = await fs46.readFile(path49.join(projectPath, filePath), "utf-8");
+          const tokens = tokenizeFile(content, filePath);
+          return { filePath, tokens };
+        } catch {
+          return { filePath, tokens: [] };
+        }
+      })
+    );
+    for (const { filePath, tokens } of results) {
+      if (tokens.length === 0) continue;
+      documents[filePath] = { tokens, length: tokens.length };
+      totalLength += tokens.length;
+      const tfMap = /* @__PURE__ */ new Map();
+      for (const token of tokens) {
+        tfMap.set(token, (tfMap.get(token) || 0) + 1);
+      }
+      for (const [token, tf] of tfMap) {
+        if (!invertedIndex[token]) {
+          invertedIndex[token] = [];
+        }
+        invertedIndex[token].push({ path: filePath, tf });
+      }
+    }
+  }
+  const totalDocs = Object.keys(documents).length;
+  return {
+    documents,
+    invertedIndex,
+    avgDocLength: totalDocs > 0 ? totalLength / totalDocs : 0,
+    totalDocs,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function saveIndex(projectId, index) {
+  const storable = {
+    invertedIndex: index.invertedIndex,
+    avgDocLength: index.avgDocLength,
+    totalDocs: index.totalDocs,
+    builtAt: index.builtAt,
+    // Store document lengths (needed for scoring) but not full token lists
+    docLengths: Object.fromEntries(Object.entries(index.documents).map(([p, d]) => [p, d.length]))
+  };
+  database_default.setDoc(projectId, INDEX_KEY, storable);
+}
+async function indexProject(projectPath, projectId) {
+  const index = await buildIndex(projectPath);
+  saveIndex(projectId, index);
+  return index;
+}
+var INDEXABLE_EXTENSIONS, STOP_WORDS, SKIP_DIRS, INDEX_KEY;
+var init_bm25 = __esm({
+  "core/domain/bm25.ts"() {
+    "use strict";
+    init_database();
+    INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".go",
+      ".rs",
+      ".java",
+      ".cs",
+      ".rb",
+      ".php",
+      ".vue",
+      ".svelte"
+    ]);
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "shall",
+      "can",
+      "of",
+      "in",
+      "to",
+      "for",
+      "with",
+      "on",
+      "at",
+      "from",
+      "by",
+      "as",
+      "or",
+      "and",
+      "but",
+      "if",
+      "not",
+      "no",
+      "so",
+      "up",
+      "out",
+      "this",
+      "that",
+      "it",
+      "its",
+      "all",
+      "any",
+      // Code noise
+      "import",
+      "export",
+      "default",
+      "const",
+      "let",
+      "var",
+      "function",
+      "class",
+      "interface",
+      "type",
+      "return",
+      "new",
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "void",
+      "async",
+      "await",
+      "static",
+      "public",
+      "private",
+      "protected",
+      "readonly",
+      "string",
+      "number",
+      "boolean",
+      "object",
+      "array"
+    ]);
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      "coverage",
+      ".cache",
+      ".turbo",
+      ".vercel",
+      "__pycache__",
+      "vendor",
+      "target"
+    ]);
+    __name(splitIdentifier, "splitIdentifier");
+    __name(tokenizeFile, "tokenizeFile");
+    __name(listFiles2, "listFiles");
+    __name(buildIndex, "buildIndex");
+    INDEX_KEY = "bm25-index";
+    __name(saveIndex, "saveIndex");
+    __name(indexProject, "indexProject");
+  }
+});
+
+// core/domain/git-cochange.ts
+import { exec as execCallback7 } from "node:child_process";
+import { promisify as promisify15 } from "node:util";
+async function parseGitLog(projectPath, maxCommits = 100) {
+  try {
+    const { stdout } = await exec14(
+      `git log --name-only --pretty=format:'---COMMIT---' -${maxCommits}`,
+      { cwd: projectPath, maxBuffer: 10 * 1024 * 1024 }
+    );
+    const commits = [];
+    let currentFiles = null;
+    for (const line of stdout.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed === "---COMMIT---") {
+        if (currentFiles && currentFiles.size > 0 && currentFiles.size <= MAX_FILES_PER_COMMIT) {
+          commits.push(currentFiles);
+        }
+        currentFiles = /* @__PURE__ */ new Set();
+      } else if (trimmed && currentFiles) {
+        if (isSourceFile(trimmed)) {
+          currentFiles.add(trimmed);
+        }
+      }
+    }
+    if (currentFiles && currentFiles.size > 0 && currentFiles.size <= MAX_FILES_PER_COMMIT) {
+      commits.push(currentFiles);
+    }
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function isSourceFile(filePath) {
+  const sourceExtensions = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|cs|rb|php|vue|svelte)$/i;
+  return sourceExtensions.test(filePath) && !filePath.includes("node_modules/");
+}
+async function buildMatrix(projectPath, maxCommits = 100) {
+  const commitSets = await parseGitLog(projectPath, maxCommits);
+  const fileCommitCount = /* @__PURE__ */ new Map();
+  const pairCount = /* @__PURE__ */ new Map();
+  for (const files of commitSets) {
+    const fileArray = Array.from(files);
+    for (const file of fileArray) {
+      fileCommitCount.set(file, (fileCommitCount.get(file) || 0) + 1);
+    }
+    for (let i = 0; i < fileArray.length; i++) {
+      for (let j = i + 1; j < fileArray.length; j++) {
+        const key = pairKey(fileArray[i], fileArray[j]);
+        pairCount.set(key, (pairCount.get(key) || 0) + 1);
+      }
+    }
+  }
+  const matrix = {};
+  for (const [key, count] of pairCount) {
+    const [fileA, fileB] = key.split("\0");
+    const countA = fileCommitCount.get(fileA) || 0;
+    const countB = fileCommitCount.get(fileB) || 0;
+    if (countA < MIN_FILE_OCCURRENCES || countB < MIN_FILE_OCCURRENCES) continue;
+    const unionCount = countA + countB - count;
+    const similarity = unionCount > 0 ? count / unionCount : 0;
+    if (similarity < MIN_SIMILARITY) continue;
+    if (!matrix[fileA]) matrix[fileA] = {};
+    if (!matrix[fileB]) matrix[fileB] = {};
+    matrix[fileA][fileB] = similarity;
+    matrix[fileB][fileA] = similarity;
+  }
+  return {
+    matrix,
+    commitsAnalyzed: commitSets.length,
+    filesAnalyzed: fileCommitCount.size,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function pairKey(a, b) {
+  return a < b ? `${a}\0${b}` : `${b}\0${a}`;
+}
+function saveMatrix(projectId, index) {
+  database_default.setDoc(projectId, INDEX_KEY2, index);
+}
+async function indexCoChanges(projectPath, projectId, maxCommits = 100) {
+  const index = await buildMatrix(projectPath, maxCommits);
+  saveMatrix(projectId, index);
+  return index;
+}
+var exec14, MIN_SIMILARITY, MIN_FILE_OCCURRENCES, MAX_FILES_PER_COMMIT, INDEX_KEY2;
+var init_git_cochange = __esm({
+  "core/domain/git-cochange.ts"() {
+    "use strict";
+    init_database();
+    exec14 = promisify15(execCallback7);
+    MIN_SIMILARITY = 0.1;
+    MIN_FILE_OCCURRENCES = 2;
+    MAX_FILES_PER_COMMIT = 30;
+    __name(parseGitLog, "parseGitLog");
+    __name(isSourceFile, "isSourceFile");
+    __name(buildMatrix, "buildMatrix");
+    __name(pairKey, "pairKey");
+    INDEX_KEY2 = "cochange-index";
+    __name(saveMatrix, "saveMatrix");
+    __name(indexCoChanges, "indexCoChanges");
+  }
+});
+
+// core/domain/import-graph.ts
+import fs47 from "node:fs/promises";
+import path50 from "node:path";
+function extractImportSources(content) {
+  const sources = [];
+  let match;
+  const regex = new RegExp(IMPORT_REGEX.source, "g");
+  while ((match = regex.exec(content)) !== null) {
+    const source = match[1];
+    if (source.startsWith(".") || source.startsWith("@/")) {
+      sources.push(source);
+    }
+  }
+  return sources;
+}
+async function resolveImport2(source, fromFile, projectPath) {
+  let basePath;
+  if (source.startsWith("@/")) {
+    basePath = path50.join(projectPath, "src", source.slice(2));
+  } else {
+    const fromDir = path50.dirname(path50.join(projectPath, fromFile));
+    basePath = path50.resolve(fromDir, source);
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const fullPath = basePath + ext;
+    try {
+      const stat = await fs47.stat(fullPath);
+      if (stat.isFile()) {
+        return path50.relative(projectPath, fullPath);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function listFiles3(dir, projectPath) {
+  const files = [];
+  const entries = await fs47.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (SKIP_DIRS2.has(entry.name)) continue;
+    const fullPath = path50.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles3(fullPath, projectPath));
+    } else if (entry.isFile()) {
+      const ext = path50.extname(entry.name).toLowerCase();
+      if (INDEXABLE_EXTENSIONS2.has(ext)) {
+        files.push(path50.relative(projectPath, fullPath));
+      }
+    }
+  }
+  return files;
+}
+async function buildGraph(projectPath) {
+  const files = await listFiles3(projectPath, projectPath);
+  const forward = {};
+  const reverse = {};
+  let edgeCount = 0;
+  const BATCH_SIZE = 50;
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map(async (filePath) => {
+        try {
+          const content = await fs47.readFile(path50.join(projectPath, filePath), "utf-8");
+          const sources = extractImportSources(content);
+          const resolved = [];
+          for (const source of sources) {
+            const target = await resolveImport2(source, filePath, projectPath);
+            if (target && target !== filePath) {
+              resolved.push(target);
+            }
+          }
+          return { filePath, imports: resolved };
+        } catch {
+          return { filePath, imports: [] };
+        }
+      })
+    );
+    for (const { filePath, imports } of results) {
+      if (imports.length === 0) continue;
+      forward[filePath] = imports;
+      edgeCount += imports.length;
+      for (const target of imports) {
+        if (!reverse[target]) reverse[target] = [];
+        reverse[target].push(filePath);
+      }
+    }
+  }
+  return {
+    forward,
+    reverse,
+    fileCount: files.length,
+    edgeCount,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function saveGraph(projectId, graph) {
+  database_default.setDoc(projectId, INDEX_KEY3, graph);
+}
+async function indexImports(projectPath, projectId) {
+  const graph = await buildGraph(projectPath);
+  saveGraph(projectId, graph);
+  return graph;
+}
+var INDEXABLE_EXTENSIONS2, SKIP_DIRS2, RESOLVE_EXTENSIONS, IMPORT_REGEX, INDEX_KEY3;
+var init_import_graph = __esm({
+  "core/domain/import-graph.ts"() {
+    "use strict";
+    init_database();
+    INDEXABLE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+    SKIP_DIRS2 = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      "coverage",
+      ".cache",
+      ".turbo",
+      ".vercel"
+    ]);
+    RESOLVE_EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"];
+    IMPORT_REGEX = /(?:import|from)\s+['"]([^'"]+)['"]/g;
+    __name(extractImportSources, "extractImportSources");
+    __name(resolveImport2, "resolveImport");
+    __name(listFiles3, "listFiles");
+    __name(buildGraph, "buildGraph");
+    INDEX_KEY3 = "import-graph";
+    __name(saveGraph, "saveGraph");
+    __name(indexImports, "indexImports");
+  }
+});
+
+// core/services/context-generator.ts
+import fs48 from "node:fs/promises";
+import path51 from "node:path";
 var ContextFileGenerator;
 var init_context_generator = __esm({
   "core/services/context-generator.ts"() {
@@ -25037,10 +25547,10 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs46.readFile(filePath, "utf-8");
+          const existingContent = await fs48.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
-            const filename = path49.basename(filePath);
+            const filename = path51.basename(filePath);
             console.warn(`\u26A0\uFE0F  ${filename} has invalid preserve blocks:`);
             for (const error of validation.errors) {
               console.warn(`   ${error}`);
@@ -25049,13 +25559,13 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs46.writeFile(filePath, finalContent, "utf-8");
+        await fs48.writeFile(filePath, finalContent, "utf-8");
       }
       /**
        * Generate all context files in parallel
        */
       async generate(git, stats, commands, agents, sources) {
-        const contextPath = path49.join(this.config.globalPath, "context");
+        const contextPath = path51.join(this.config.globalPath, "context");
         await Promise.all([
           this.generateClaudeMd(contextPath, git, stats, commands, agents, sources),
           this.generateNowMd(contextPath),
@@ -25155,7 +25665,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        const claudePath = path49.join(contextPath, "CLAUDE.md");
+        const claudePath = path51.join(contextPath, "CLAUDE.md");
         await this.writeWithPreservation(claudePath, content);
       }
       /**
@@ -25164,8 +25674,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path49.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs46.readFile(statePath, "utf-8"));
+          const statePath = path51.join(this.config.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs48.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -25181,7 +25691,7 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await this.writeWithPreservation(path49.join(contextPath, "now.md"), content);
+        await this.writeWithPreservation(path51.join(contextPath, "now.md"), content);
       }
       /**
        * Generate next.md - task queue
@@ -25189,15 +25699,15 @@ Use \`p. task "description"\` to start working.
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path49.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs46.readFile(queuePath, "utf-8"));
+          const queuePath = path51.join(this.config.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs48.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(path49.join(contextPath, "next.md"), content);
+        await this.writeWithPreservation(path51.join(contextPath, "next.md"), content);
       }
       /**
        * Generate ideas.md - captured ideas
@@ -25205,15 +25715,15 @@ ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}
       async generateIdeasMd(contextPath) {
         let ideas = { ideas: [] };
         try {
-          const ideasPath = path49.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs46.readFile(ideasPath, "utf-8"));
+          const ideasPath = path51.join(this.config.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs48.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(path49.join(contextPath, "ideas.md"), content);
+        await this.writeWithPreservation(path51.join(contextPath, "ideas.md"), content);
       }
       /**
        * Generate shipped.md - completed features
@@ -25223,8 +25733,8 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
           shipped: []
         };
         try {
-          const shippedPath = path49.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs46.readFile(shippedPath, "utf-8"));
+          const shippedPath = path51.join(this.config.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs48.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -25233,7 +25743,7 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await this.writeWithPreservation(path49.join(contextPath, "shipped.md"), content);
+        await this.writeWithPreservation(path51.join(contextPath, "shipped.md"), content);
       }
       // ==========================================================================
       // MONOREPO SUPPORT
@@ -25262,9 +25772,9 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
             commands,
             agents
           );
-          const claudePath = path49.join(pkg.path, "CLAUDE.md");
+          const claudePath = path51.join(pkg.path, "CLAUDE.md");
           await this.writeWithPreservation(claudePath, content);
-          generatedFiles.push(path49.relative(this.config.projectPath, claudePath));
+          generatedFiles.push(path51.relative(this.config.projectPath, claudePath));
         }
         return generatedFiles;
       }
@@ -25277,8 +25787,8 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
         let pkgVersion = stats.version;
         let pkgName = pkg.name;
         try {
-          const pkgJsonPath = path49.join(pkg.path, "package.json");
-          const pkgJson = JSON.parse(await fs46.readFile(pkgJsonPath, "utf-8"));
+          const pkgJsonPath = path51.join(pkg.path, "package.json");
+          const pkgJson = JSON.parse(await fs48.readFile(pkgJsonPath, "utf-8"));
           pkgVersion = pkgJson.version || stats.version;
           pkgName = pkgJson.name || pkg.name;
         } catch {
@@ -25343,8 +25853,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 });
 
 // core/services/local-state-generator.ts
-import fs47 from "node:fs/promises";
-import path50 from "node:path";
+import fs49 from "node:fs/promises";
+import path52 from "node:path";
 var LOCAL_STATE_FILENAME, LocalStateGenerator, localStateGenerator;
 var init_local_state_generator = __esm({
   "core/services/local-state-generator.ts"() {
@@ -25359,17 +25869,17 @@ var init_local_state_generator = __esm({
        * Generate .prjct-state.md in the project root
        */
       async generate(projectPath, state) {
-        const filePath = path50.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path52.join(projectPath, LOCAL_STATE_FILENAME);
         const content = this.toMarkdown(state);
-        await fs47.writeFile(filePath, content, "utf-8");
+        await fs49.writeFile(filePath, content, "utf-8");
       }
       /**
        * Remove local state file
        */
       async remove(projectPath) {
-        const filePath = path50.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path52.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs47.unlink(filePath);
+          await fs49.unlink(filePath);
         } catch (error) {
           if (!isNotFoundError(error)) throw error;
         }
@@ -25378,9 +25888,9 @@ var init_local_state_generator = __esm({
        * Check if local state file exists
        */
       async exists(projectPath) {
-        const filePath = path50.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path52.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs47.access(filePath);
+          await fs49.access(filePath);
           return true;
         } catch {
           return false;
@@ -25459,11 +25969,11 @@ var init_local_state_generator = __esm({
 });
 
 // core/services/skill-lock.ts
-import fs48 from "node:fs/promises";
+import fs50 from "node:fs/promises";
 import os14 from "node:os";
-import path51 from "node:path";
+import path53 from "node:path";
 function getLockFilePath() {
-  return path51.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
+  return path53.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
 }
 function createEmptyLockFile() {
   return {
@@ -25474,7 +25984,7 @@ function createEmptyLockFile() {
 }
 async function read() {
   try {
-    const content = await fs48.readFile(getLockFilePath(), "utf-8");
+    const content = await fs50.readFile(getLockFilePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return createEmptyLockFile();
@@ -25482,9 +25992,9 @@ async function read() {
 }
 async function write(lockFile) {
   const lockPath = getLockFilePath();
-  await fs48.mkdir(path51.dirname(lockPath), { recursive: true });
+  await fs50.mkdir(path53.dirname(lockPath), { recursive: true });
   lockFile.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs48.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
+  await fs50.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
 }
 async function addEntry(entry) {
   const lockFile = await read();
@@ -25536,15 +26046,15 @@ var init_skill_lock = __esm({
 });
 
 // core/services/skill-installer.ts
-import { exec as execCallback7 } from "node:child_process";
-import fs49 from "node:fs/promises";
+import { exec as execCallback8 } from "node:child_process";
+import fs51 from "node:fs/promises";
 import os15 from "node:os";
-import path52 from "node:path";
-import { promisify as promisify15 } from "node:util";
+import path54 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("~") ? path52.join(os15.homedir(), source.slice(1)) : path52.resolve(source);
+    const resolvedPath = source.startsWith("~") ? path54.join(os15.homedir(), source.slice(1)) : path54.resolve(source);
     return {
       type: "local",
       localPath: resolvedPath,
@@ -25582,22 +26092,22 @@ function parseSource(source) {
 async function discoverSkills(dir) {
   const skills = [];
   try {
-    const rootSkill = path52.join(dir, "SKILL.md");
-    await fs49.access(rootSkill);
-    const dirName = path52.basename(dir);
+    const rootSkill = path54.join(dir, "SKILL.md");
+    await fs51.access(rootSkill);
+    const dirName = path54.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 = path52.basename(path52.dirname(filePath));
+    const name = path54.basename(path54.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 = path52.basename(path52.dirname(filePath));
+    const name = path54.basename(path54.dirname(filePath));
     if (!skills.some((s) => s.name === name)) {
       skills.push({ name, filePath });
     }
@@ -25633,16 +26143,16 @@ ${prjctBlock.join("\n")}
 ${content}`;
 }
 function getInstallDir() {
-  return path52.join(os15.homedir(), ".claude", "skills");
+  return path54.join(os15.homedir(), ".claude", "skills");
 }
 async function installSkillFile(sourcePath, name, source, sha) {
   const installDir = getInstallDir();
-  const targetDir = path52.join(installDir, name);
-  const targetPath = path52.join(targetDir, "SKILL.md");
-  const content = await fs49.readFile(sourcePath, "utf-8");
+  const targetDir = path54.join(installDir, name);
+  const targetPath = path54.join(targetDir, "SKILL.md");
+  const content = await fs51.readFile(sourcePath, "utf-8");
   const enrichedContent = injectSourceMetadata(content, source, sha);
-  await fs49.mkdir(targetDir, { recursive: true });
-  await fs49.writeFile(targetPath, enrichedContent, "utf-8");
+  await fs51.mkdir(targetDir, { recursive: true });
+  await fs51.writeFile(targetPath, enrichedContent, "utf-8");
   return {
     name,
     filePath: targetPath,
@@ -25659,13 +26169,13 @@ async function installFromGitHub(source) {
     );
     return result;
   }
-  const tmpDir = path52.join(os15.tmpdir(), `prjct-skill-${Date.now()}`);
+  const tmpDir = path54.join(os15.tmpdir(), `prjct-skill-${Date.now()}`);
   try {
     const cloneUrl = `https://github.com/${source.owner}/${source.repo}.git`;
-    await exec14(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
+    await exec15(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
     let sha;
     try {
-      const { stdout } = await exec14("git rev-parse HEAD", {
+      const { stdout } = await exec15("git rev-parse HEAD", {
         cwd: tmpDir,
         timeout: getTimeout("TOOL_CHECK")
       });
@@ -25703,7 +26213,7 @@ async function installFromGitHub(source) {
     }
   } finally {
     try {
-      await fs49.rm(tmpDir, { recursive: true, force: true });
+      await fs51.rm(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -25713,14 +26223,14 @@ async function installFromLocal(source) {
   const result = { installed: [], skipped: [], errors: [] };
   const localPath = source.localPath;
   try {
-    await fs49.access(localPath);
+    await fs51.access(localPath);
   } catch {
     result.errors.push(`Local path not found: ${localPath}`);
     return result;
   }
-  const stat = await fs49.stat(localPath);
+  const stat = await fs51.stat(localPath);
   if (stat.isFile()) {
-    const name = path52.basename(path52.dirname(localPath));
+    const name = path54.basename(path54.dirname(localPath));
     try {
       const installed = await installSkillFile(localPath, name, source);
       const lockEntry = {
@@ -25760,14 +26270,14 @@ async function installFromLocal(source) {
 }
 async function remove(name) {
   const installDir = getInstallDir();
-  const subdirPath = path52.join(installDir, name);
+  const subdirPath = path54.join(installDir, name);
   try {
-    await fs49.rm(subdirPath, { recursive: true, force: true });
+    await fs51.rm(subdirPath, { recursive: true, force: true });
   } catch {
   }
-  const flatPath = path52.join(installDir, `${name}.md`);
+  const flatPath = path54.join(installDir, `${name}.md`);
   try {
-    await fs49.rm(flatPath, { force: true });
+    await fs51.rm(flatPath, { force: true });
   } catch {
   }
   return skillLock.removeEntry(name);
@@ -25787,7 +26297,7 @@ async function install(sourceStr) {
       };
   }
 }
-var exec14, skillInstaller;
+var exec15, skillInstaller;
 var init_skill_installer = __esm({
   "core/services/skill-installer.ts"() {
     "use strict";
@@ -25795,7 +26305,7 @@ var init_skill_installer = __esm({
     init_fs();
     init_dependency_validator();
     init_skill_lock();
-    exec14 = promisify15(execCallback7);
+    exec15 = promisify16(execCallback8);
     __name(parseSource, "parseSource");
     __name(discoverSkills, "discoverSkills");
     __name(injectSourceMetadata, "injectSourceMetadata");
@@ -25815,8 +26325,8 @@ var init_skill_installer = __esm({
 });
 
 // core/services/stack-detector.ts
-import fs50 from "node:fs/promises";
-import path53 from "node:path";
+import fs52 from "node:fs/promises";
+import path55 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -25975,8 +26485,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path53.join(this.projectPath, "package.json");
-          const content = await fs50.readFile(pkgPath, "utf-8");
+          const pkgPath = path55.join(this.projectPath, "package.json");
+          const content = await fs52.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -25987,7 +26497,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs50.access(path53.join(this.projectPath, filename));
+          await fs52.access(path55.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -25998,16 +26508,16 @@ var init_stack_detector = __esm({
 });
 
 // core/services/sync-verifier.ts
-import { exec as exec15 } from "node:child_process";
-import fs51 from "node:fs/promises";
-import path54 from "node:path";
-import { promisify as promisify16 } from "node:util";
+import { exec as exec16 } from "node:child_process";
+import fs53 from "node:fs/promises";
+import path56 from "node:path";
+import { promisify as promisify17 } from "node:util";
 var execAsync10, BUILTIN_CHECKS, SyncVerifier, syncVerifier;
 var init_sync_verifier = __esm({
   "core/services/sync-verifier.ts"() {
     "use strict";
     init_fs();
-    execAsync10 = promisify16(exec15);
+    execAsync10 = promisify17(exec16);
     BUILTIN_CHECKS = {
       /**
        * Verify all expected context files exist after sync
@@ -26017,9 +26527,9 @@ var init_sync_verifier = __esm({
         const expected = ["context/CLAUDE.md"];
         const missing = [];
         for (const file of expected) {
-          const filePath = path54.join(globalPath, file);
+          const filePath = path56.join(globalPath, file);
           try {
-            await fs51.access(filePath);
+            await fs53.access(filePath);
           } catch {
             missing.push(file);
           }
@@ -26040,9 +26550,9 @@ var init_sync_verifier = __esm({
         const jsonFiles = ["storage/state.json"];
         const invalid = [];
         for (const file of jsonFiles) {
-          const filePath = path54.join(globalPath, file);
+          const filePath = path56.join(globalPath, file);
           try {
-            const content = await fs51.readFile(filePath, "utf-8");
+            const content = await fs53.readFile(filePath, "utf-8");
             JSON.parse(content);
           } catch (error) {
             if (!isNotFoundError(error)) {
@@ -26063,7 +26573,7 @@ var init_sync_verifier = __esm({
        */
       async noSensitiveData(globalPath) {
         const start = Date.now();
-        const contextDir = path54.join(globalPath, "context");
+        const contextDir = path56.join(globalPath, "context");
         const patterns = [
           /(?:api[_-]?key|apikey)\s*[:=]\s*['"][^'"]{10,}/i,
           /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{4,}/i,
@@ -26071,10 +26581,10 @@ var init_sync_verifier = __esm({
         ];
         const violations = [];
         try {
-          const files = await fs51.readdir(contextDir);
+          const files = await fs53.readdir(contextDir);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
-            const content = await fs51.readFile(path54.join(contextDir, file), "utf-8");
+            const content = await fs53.readFile(path56.join(contextDir, file), "utf-8");
             for (const pattern of patterns) {
               if (pattern.test(content)) {
                 violations.push(`${file}: potential sensitive data detected`);
@@ -26194,16 +26704,19 @@ var init_sync_verifier = __esm({
 });
 
 // core/services/sync-service.ts
-import { exec as exec16 } from "node:child_process";
-import fs52 from "node:fs/promises";
+import { exec as exec17 } from "node:child_process";
+import fs54 from "node:fs/promises";
 import os16 from "node:os";
-import path55 from "node:path";
-import { promisify as promisify17 } from "node:util";
+import path57 from "node:path";
+import { promisify as promisify18 } from "node:util";
 var execAsync11, SyncService, syncService;
 var init_sync_service = __esm({
   "core/services/sync-service.ts"() {
     "use strict";
     init_ai_tools();
+    init_bm25();
+    init_git_cochange();
+    init_import_graph();
     init_errors();
     init_command_installer();
     init_config_manager();
@@ -26219,7 +26732,7 @@ var init_sync_service = __esm({
     init_skill_installer();
     init_stack_detector();
     init_sync_verifier();
-    execAsync11 = promisify17(exec16);
+    execAsync11 = promisify18(exec17);
     SyncService = class {
       static {
         __name(this, "SyncService");
@@ -26281,6 +26794,17 @@ var init_sync_service = __esm({
             this.detectCommands(),
             this.detectStack()
           ]);
+          try {
+            await Promise.all([
+              indexProject(this.projectPath, this.projectId),
+              indexImports(this.projectPath, this.projectId),
+              indexCoChanges(this.projectPath, this.projectId)
+            ]);
+          } catch (error) {
+            logger_default.debug("File ranking index build failed (non-critical)", {
+              error: getErrorMessage(error)
+            });
+          }
           const agents = await this.generateAgents(stack, stats);
           const skills = this.configureSkills(agents);
           const skillsInstalled = await this.autoInstallSkills(agents);
@@ -26377,7 +26901,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs52.mkdir(path55.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs54.mkdir(path57.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -26448,7 +26972,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path55.basename(this.projectPath),
+          name: path57.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -26465,8 +26989,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path55.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs52.readFile(pkgPath, "utf-8"));
+          const pkgPath = path57.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs54.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -26611,12 +27135,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path55.join(this.globalPath, "agents");
+        const agentsPath = path57.join(this.globalPath, "agents");
         try {
-          const files = await fs52.readdir(agentsPath);
+          const files = await fs54.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs52.unlink(path55.join(agentsPath, file));
+              await fs54.unlink(path57.join(agentsPath, file));
             }
           }
         } catch (error) {
@@ -26665,7 +27189,7 @@ var init_sync_service = __esm({
         let resolved = content;
         for (const match of matches) {
           const partialName = match[1];
-          const partialPath = path55.join(
+          const partialPath = path57.join(
             __dirname,
             "..",
             "..",
@@ -26674,7 +27198,7 @@ var init_sync_service = __esm({
             `${partialName}.md`
           );
           try {
-            const partialContent = await fs52.readFile(partialPath, "utf-8");
+            const partialContent = await fs54.readFile(partialPath, "utf-8");
             resolved = resolved.replace(match[0], partialContent.trim());
           } catch {
             resolved = resolved.replace(match[0], `<!-- partial "${partialName}" not found -->`);
@@ -26685,7 +27209,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path55.join(
+          const templatePath = path57.join(
             __dirname,
             "..",
             "..",
@@ -26694,7 +27218,7 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs52.readFile(templatePath, "utf-8");
+          content = await fs54.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
         } catch (error) {
           logger_default.debug("Workflow agent template not found, generating minimal", {
@@ -26703,12 +27227,12 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs52.writeFile(path55.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs54.writeFile(path57.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path55.join(
+          const templatePath = path57.join(
             __dirname,
             "..",
             "..",
@@ -26717,7 +27241,7 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs52.readFile(templatePath, "utf-8");
+          content = await fs54.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
@@ -26729,7 +27253,7 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs52.writeFile(path55.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs54.writeFile(path57.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -26797,8 +27321,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]))
         };
-        fs52.writeFile(
-          path55.join(this.globalPath, "config", "skills.json"),
+        fs54.writeFile(
+          path57.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch((error) => {
@@ -26816,7 +27340,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       async autoInstallSkills(agents) {
         const results = [];
         try {
-          const mappingsPath = path55.join(
+          const mappingsPath = path57.join(
             __dirname,
             "..",
             "..",
@@ -26824,7 +27348,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
             "config",
             "skill-mappings.json"
           );
-          const mappingsContent = await fs52.readFile(mappingsPath, "utf-8");
+          const mappingsContent = await fs54.readFile(mappingsPath, "utf-8");
           const mappings = JSON.parse(mappingsContent);
           const agentToSkillMap = mappings.agentToSkillMap || {};
           const packagesToInstall = [];
@@ -26837,18 +27361,18 @@ You are the ${name} expert for this project. Apply best practices for the detect
             }
           }
           if (packagesToInstall.length === 0) return results;
-          const skillsDir = path55.join(os16.homedir(), ".claude", "skills");
+          const skillsDir = path57.join(os16.homedir(), ".claude", "skills");
           for (const { pkg, agent } of packagesToInstall) {
             const skillName = pkg.split("/").pop() || pkg;
-            const subdirPath = path55.join(skillsDir, skillName, "SKILL.md");
-            const flatPath = path55.join(skillsDir, `${skillName}.md`);
+            const subdirPath = path57.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path57.join(skillsDir, `${skillName}.md`);
             let alreadyInstalled = false;
             try {
-              await fs52.access(subdirPath);
+              await fs54.access(subdirPath);
               alreadyInstalled = true;
             } catch {
               try {
-                await fs52.access(flatPath);
+                await fs54.access(flatPath);
                 alreadyInstalled = true;
               } catch {
               }
@@ -26900,10 +27424,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path55.join(this.globalPath, "project.json");
+        const projectJsonPath = path57.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs52.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs54.readFile(projectJsonPath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing project.json", {
             path: projectJsonPath,
@@ -26929,16 +27453,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 fs52.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs54.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path55.join(this.globalPath, "storage", "state.json");
+        const statePath = path57.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs52.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs54.readFile(statePath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing state.json", { path: statePath, error: getErrorMessage(error) });
         }
@@ -26966,7 +27490,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 fs52.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs54.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
         try {
           await localStateGenerator.generate(
             this.projectPath,
@@ -26980,7 +27504,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path55.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path57.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: getTimestamp(),
           action: "sync",
@@ -26989,7 +27513,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs52.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs54.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -27009,8 +27533,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 = path55.join(this.globalPath, file);
-            const content = await fs52.readFile(filePath, "utf-8");
+            const filePath = path57.join(this.globalPath, file);
+            const content = await fs54.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Context file not found for metrics", { file, error: getErrorMessage(error) });
@@ -27018,8 +27542,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
         }
         for (const agent of agents) {
           try {
-            const agentPath = path55.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs52.readFile(agentPath, "utf-8");
+            const agentPath = path57.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs54.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Agent file not found for metrics", {
@@ -27081,7 +27605,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs52.access(path55.join(this.projectPath, filename));
+          await fs54.access(path57.join(this.projectPath, filename));
           return true;
         } catch (error) {
           logger_default.debug("File not found", { filename, error: getErrorMessage(error) });
@@ -27090,8 +27614,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path55.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs52.readFile(pkgPath, "utf-8"));
+          const pkgPath = path57.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs54.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch (error) {
           logger_default.debug("Failed to read CLI version", { error: getErrorMessage(error) });
@@ -27252,22 +27776,22 @@ __export(uninstall_exports, {
   uninstall: () => uninstall
 });
 import { execSync as execSync3 } from "node:child_process";
-import fs53 from "node:fs/promises";
+import fs55 from "node:fs/promises";
 import os17 from "node:os";
-import path56 from "node:path";
+import path58 from "node:path";
 import readline2 from "node:readline";
 import chalk12 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs53.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs55.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path56.join(dirPath, entry.name);
+      const entryPath = path58.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs53.stat(entryPath);
+          const stats = await fs55.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -27286,7 +27810,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs53.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs55.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -27319,7 +27843,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = await fileExists(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path56.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path58.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -27329,12 +27853,12 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path56.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path58.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = await fileExists(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
     try {
-      const content = await fs53.readFile(claudeMdPath, "utf-8");
+      const content = await fs55.readFile(claudeMdPath, "utf-8");
       hasPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -27363,7 +27887,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path56.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path58.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = await fileExists(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -27379,12 +27903,12 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path56.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path58.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = await fileExists(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
     try {
-      const content = await fs53.readFile(geminiMdPath, "utf-8");
+      const content = await fs55.readFile(geminiMdPath, "utf-8");
       hasGeminiPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -27401,7 +27925,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs53.readFile(filePath, "utf-8");
+    const content = await fs55.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -27410,9 +27934,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 fs53.unlink(filePath);
+      await fs55.unlink(filePath);
     } else {
-      await fs53.writeFile(filePath, `${newContent}
+      await fs55.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -27423,12 +27947,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 = path56.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path58.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs53.mkdir(backupDir, { recursive: true });
+    await fs55.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (await fileExists(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path56.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path58.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -27436,15 +27960,15 @@ async function createBackup3() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs53.mkdir(dest, { recursive: true });
-  const entries = await fs53.readdir(src, { withFileTypes: true });
+  await fs55.mkdir(dest, { recursive: true });
+  const entries = await fs55.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path56.join(src, entry.name);
-    const destPath = path56.join(dest, entry.name);
+    const srcPath = path58.join(src, entry.name);
+    const destPath = path58.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs53.copyFile(srcPath, destPath);
+      await fs55.copyFile(srcPath, destPath);
     }
   }
 }
@@ -27460,10 +27984,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs53.rm(item.path, { recursive: true, force: true });
+        await fs55.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs53.unlink(item.path);
+        await fs55.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -27640,7 +28164,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path57 from "node:path";
+import path59 from "node:path";
 import chalk13 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -27861,7 +28385,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: ${path57.basename(this.projectPath)}`));
+        console.log(chalk13.dim(`   Project: ${path59.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("");
@@ -28592,9 +29116,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync4 } from "node:child_process";
-import fs54 from "node:fs/promises";
+import fs56 from "node:fs/promises";
 import os18 from "node:os";
-import path58 from "node:path";
+import path60 from "node:path";
 import chalk15 from "chalk";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
@@ -28733,12 +29257,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path58.join(os18.homedir(), ".gemini", "commands");
-    const routerSource = path58.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
-    const routerDest = path58.join(geminiCommandsDir, "p.toml");
-    await fs54.mkdir(geminiCommandsDir, { recursive: true });
+    const geminiCommandsDir = path60.join(os18.homedir(), ".gemini", "commands");
+    const routerSource = path60.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
+    const routerDest = path60.join(geminiCommandsDir, "p.toml");
+    await fs56.mkdir(geminiCommandsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs54.copyFile(routerSource, routerDest);
+      await fs56.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -28749,15 +29273,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path58.join(os18.homedir(), ".gemini");
-    const globalConfigPath = path58.join(geminiDir, "GEMINI.md");
-    const templatePath = path58.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
-    await fs54.mkdir(geminiDir, { recursive: true });
-    const templateContent = await fs54.readFile(templatePath, "utf-8");
+    const geminiDir = path60.join(os18.homedir(), ".gemini");
+    const globalConfigPath = path60.join(geminiDir, "GEMINI.md");
+    const templatePath = path60.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
+    await fs56.mkdir(geminiDir, { recursive: true });
+    const templateContent = await fs56.readFile(templatePath, "utf-8");
     let existingContent = "";
     let configExists = false;
     try {
-      existingContent = await fs54.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs56.readFile(globalConfigPath, "utf-8");
       configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -28767,7 +29291,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!configExists) {
-      await fs54.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs56.writeFile(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -28777,7 +29301,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      await fs54.writeFile(globalConfigPath, updatedContent2, "utf-8");
+      await fs56.writeFile(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -28789,7 +29313,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    await fs54.writeFile(globalConfigPath, updatedContent, "utf-8");
+    await fs56.writeFile(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     logger_default.warn(`Gemini config warning: ${getErrorMessage2(error)}`);
@@ -28798,18 +29322,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path58.join(os18.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = path58.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = path58.join(prjctSkillDir, "SKILL.md");
-    const templatePath = path58.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
-    await fs54.mkdir(prjctSkillDir, { recursive: true });
+    const antigravitySkillsDir = path60.join(os18.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path60.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path60.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path60.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
+    await fs56.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 fs54.readFile(templatePath, "utf-8");
-    await fs54.writeFile(skillMdPath, templateContent, "utf-8");
+    const templateContent = await fs56.readFile(templatePath, "utf-8");
+    await fs56.writeFile(skillMdPath, templateContent, "utf-8");
     return { success: true, action: skillExists ? "updated" : "created" };
   } catch (error) {
     logger_default.warn(`Antigravity skill warning: ${getErrorMessage2(error)}`);
@@ -28828,24 +29352,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = path58.join(projectRoot, ".cursor");
-    const rulesDir = path58.join(cursorDir, "rules");
-    const commandsDir = path58.join(cursorDir, "commands");
-    const routerMdcDest = path58.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = path58.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = path58.join(PACKAGE_ROOT, "templates", "cursor", "commands");
-    await fs54.mkdir(rulesDir, { recursive: true });
-    await fs54.mkdir(commandsDir, { recursive: true });
+    const cursorDir = path60.join(projectRoot, ".cursor");
+    const rulesDir = path60.join(cursorDir, "rules");
+    const commandsDir = path60.join(cursorDir, "commands");
+    const routerMdcDest = path60.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path60.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path60.join(PACKAGE_ROOT, "templates", "cursor", "commands");
+    await fs56.mkdir(rulesDir, { recursive: true });
+    await fs56.mkdir(commandsDir, { recursive: true });
     if (await fileExists(routerMdcSource)) {
-      await fs54.copyFile(routerMdcSource, routerMdcDest);
+      await fs56.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
     if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await fs54.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
+      const commandFiles = (await fs56.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path58.join(cursorCommandsSource, file);
-        const dest = path58.join(commandsDir, file);
-        await fs54.copyFile(src, dest);
+        const src = path60.join(cursorCommandsSource, file);
+        const dest = path60.join(commandsDir, file);
+        await fs56.copyFile(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -28859,7 +29383,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path58.join(projectRoot, ".gitignore");
+    const gitignorePath = path60.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -28874,7 +29398,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs54.readFile(gitignorePath, "utf-8");
+      content = await fs56.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -28889,7 +29413,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs54.writeFile(gitignorePath, newContent, "utf-8");
+    await fs56.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -28897,11 +29421,11 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasCursorProject(projectRoot) {
-  return await fileExists(path58.join(projectRoot, ".cursor"));
+  return await fileExists(path60.join(projectRoot, ".cursor"));
 }
 async function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path58.join(projectRoot, ".cursor");
-  const routerPath = path58.join(cursorDir, "rules", "prjct.mdc");
+  const cursorDir = path60.join(projectRoot, ".cursor");
+  const routerPath = path60.join(cursorDir, "rules", "prjct.mdc");
   return await fileExists(cursorDir) && !await fileExists(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
@@ -28912,26 +29436,26 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = path58.join(projectRoot, ".windsurf");
-    const rulesDir = path58.join(windsurfDir, "rules");
-    const workflowsDir = path58.join(windsurfDir, "workflows");
-    const routerDest = path58.join(rulesDir, "prjct.md");
-    const routerSource = path58.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = path58.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
-    await fs54.mkdir(rulesDir, { recursive: true });
-    await fs54.mkdir(workflowsDir, { recursive: true });
+    const windsurfDir = path60.join(projectRoot, ".windsurf");
+    const rulesDir = path60.join(windsurfDir, "rules");
+    const workflowsDir = path60.join(windsurfDir, "workflows");
+    const routerDest = path60.join(rulesDir, "prjct.md");
+    const routerSource = path60.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path60.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
+    await fs56.mkdir(rulesDir, { recursive: true });
+    await fs56.mkdir(workflowsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs54.copyFile(routerSource, routerDest);
+      await fs56.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
     if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await fs54.readdir(windsurfWorkflowsSource)).filter(
+      const workflowFiles = (await fs56.readdir(windsurfWorkflowsSource)).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of workflowFiles) {
-        const src = path58.join(windsurfWorkflowsSource, file);
-        const dest = path58.join(workflowsDir, file);
-        await fs54.copyFile(src, dest);
+        const src = path60.join(windsurfWorkflowsSource, file);
+        const dest = path60.join(workflowsDir, file);
+        await fs56.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -28945,7 +29469,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path58.join(projectRoot, ".gitignore");
+    const gitignorePath = path60.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -28960,7 +29484,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs54.readFile(gitignorePath, "utf-8");
+      content = await fs56.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -28975,7 +29499,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs54.writeFile(gitignorePath, newContent, "utf-8");
+    await fs56.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -28983,32 +29507,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasWindsurfProject(projectRoot) {
-  return await fileExists(path58.join(projectRoot, ".windsurf"));
+  return await fileExists(path60.join(projectRoot, ".windsurf"));
 }
 async function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path58.join(projectRoot, ".windsurf");
-  const routerPath = path58.join(windsurfDir, "rules", "prjct.md");
+  const windsurfDir = path60.join(projectRoot, ".windsurf");
+  const routerPath = path60.join(windsurfDir, "rules", "prjct.md");
   return await fileExists(windsurfDir) && !await fileExists(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path58.join(os18.homedir(), ".prjct-cli", "projects");
+    const projectsDir = path60.join(os18.homedir(), ".prjct-cli", "projects");
     if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = (await fs54.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await fs56.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path58.join(projectsDir, projectId, "project.json");
+      const projectJsonPath = path60.join(projectsDir, projectId, "project.json");
       if (!await fileExists(projectJsonPath)) {
         continue;
       }
       try {
-        const content = await fs54.readFile(projectJsonPath, "utf8");
+        const content = await fs56.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          await fs54.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await fs56.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -29030,7 +29554,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
   if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(await fs54.readFile(settingsPath, "utf8"));
+      settings = JSON.parse(await fs56.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -29038,42 +29562,42 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  await fs54.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await fs56.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path58.join(os18.homedir(), ".claude");
-    const settingsPath = path58.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = path58.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path58.join(os18.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = path58.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = path58.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = path58.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = path58.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = path58.join(prjctStatusLineDir, "config.json");
-    const assetsDir = path58.join(PACKAGE_ROOT, "assets", "statusline");
-    const sourceScript = path58.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = path58.join(assetsDir, "themes");
-    const sourceLibDir = path58.join(assetsDir, "lib");
-    const sourceComponentsDir = path58.join(assetsDir, "components");
-    const sourceConfigPath = path58.join(assetsDir, "default-config.json");
+    const claudeDir = path60.join(os18.homedir(), ".claude");
+    const settingsPath = path60.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path60.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path60.join(os18.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path60.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path60.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path60.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path60.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path60.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path60.join(PACKAGE_ROOT, "assets", "statusline");
+    const sourceScript = path60.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path60.join(assetsDir, "themes");
+    const sourceLibDir = path60.join(assetsDir, "lib");
+    const sourceComponentsDir = path60.join(assetsDir, "components");
+    const sourceConfigPath = path60.join(assetsDir, "default-config.json");
     if (!await fileExists(claudeDir)) {
-      await fs54.mkdir(claudeDir, { recursive: true });
+      await fs56.mkdir(claudeDir, { recursive: true });
     }
     if (!await fileExists(prjctStatusLineDir)) {
-      await fs54.mkdir(prjctStatusLineDir, { recursive: true });
+      await fs56.mkdir(prjctStatusLineDir, { recursive: true });
     }
     if (!await fileExists(prjctThemesDir)) {
-      await fs54.mkdir(prjctThemesDir, { recursive: true });
+      await fs56.mkdir(prjctThemesDir, { recursive: true });
     }
     if (!await fileExists(prjctLibDir)) {
-      await fs54.mkdir(prjctLibDir, { recursive: true });
+      await fs56.mkdir(prjctLibDir, { recursive: true });
     }
     if (!await fileExists(prjctComponentsDir)) {
-      await fs54.mkdir(prjctComponentsDir, { recursive: true });
+      await fs56.mkdir(prjctComponentsDir, { recursive: true });
     }
     if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await fs54.readFile(prjctStatusLinePath, "utf8");
+      const existingContent = await fs56.readFile(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -29081,7 +29605,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          await fs54.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await fs56.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         await installStatusLineModules(sourceLibDir, prjctLibDir);
         await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -29091,21 +29615,21 @@ async function installStatusLine() {
       }
     }
     if (await fileExists(sourceScript)) {
-      let scriptContent = await fs54.readFile(sourceScript, "utf8");
+      let scriptContent = await fs56.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await fs54.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs56.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
       await installStatusLineModules(sourceLibDir, prjctLibDir);
       await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
       if (await fileExists(sourceThemeDir)) {
-        const themes = await fs54.readdir(sourceThemeDir);
+        const themes = await fs56.readdir(sourceThemeDir);
         for (const theme of themes) {
-          const src = path58.join(sourceThemeDir, theme);
-          const dest = path58.join(prjctThemesDir, theme);
-          await fs54.copyFile(src, dest);
+          const src = path60.join(sourceThemeDir, theme);
+          const dest = path60.join(prjctThemesDir, theme);
+          await fs56.copyFile(src, dest);
         }
       }
       if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await fs54.copyFile(sourceConfigPath, prjctConfigPath);
+        await fs56.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -29140,7 +29664,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      await fs54.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs56.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -29152,10 +29676,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path58.join(os18.homedir(), ".claude");
-    const mcpConfigPath = path58.join(claudeDir, "mcp.json");
+    const claudeDir = path60.join(os18.homedir(), ".claude");
+    const mcpConfigPath = path60.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
-      await fs54.mkdir(claudeDir, { recursive: true });
+      await fs56.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -29166,16 +29690,16 @@ async function installContext7MCP() {
       }
     };
     if (await fileExists(mcpConfigPath)) {
-      const existingContent = await fs54.readFile(mcpConfigPath, "utf-8");
+      const existingContent = await fs56.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 fs54.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await fs56.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      await fs54.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      await fs56.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     logger_default.warn(`Context7 MCP setup warning: ${getErrorMessage2(error)}`);
@@ -29185,34 +29709,34 @@ async function installStatusLineModules(sourceDir, destDir) {
   if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = await fs54.readdir(sourceDir);
+  const files = await fs56.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path58.join(sourceDir, file);
-      const dest = path58.join(destDir, file);
-      await fs54.copyFile(src, dest);
-      await fs54.chmod(dest, 493);
+      const src = path60.join(sourceDir, file);
+      const dest = path60.join(destDir, file);
+      await fs56.copyFile(src, dest);
+      await fs56.chmod(dest, 493);
     }
   }
 }
 async function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
     if (await fileExists(linkPath)) {
-      const stats = await fs54.lstat(linkPath);
+      const stats = await fs56.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = await fs54.readlink(linkPath);
+        const existingTarget = await fs56.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      await fs54.unlink(linkPath);
+      await fs56.unlink(linkPath);
     }
-    await fs54.symlink(targetPath, linkPath);
+    await fs56.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
       if (await fileExists(targetPath)) {
-        await fs54.copyFile(targetPath, linkPath);
-        await fs54.chmod(linkPath, 493);
+        await fs56.copyFile(targetPath, linkPath);
+        await fs56.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -29627,7 +30151,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path59 from "node:path";
+import path61 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -29654,7 +30178,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path59.basename(projectPath);
+          const projectName = path61.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -29906,8 +30430,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs55 from "node:fs/promises";
-import path60 from "node:path";
+import fs57 from "node:fs/promises";
+import path62 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -30033,8 +30557,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path60.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs55.readFile(analysisPath, "utf-8");
+          const analysisPath = path62.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs57.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -30053,7 +30577,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path61 from "node:path";
+import path63 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -30069,7 +30593,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_exports.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path61.basename(filePath));
+          results.rotated.push(path63.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -30176,7 +30700,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path62 from "node:path";
+import path64 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -30188,7 +30712,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 = path62.join(
+    const designsPath = path64.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -30228,7 +30752,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path62.join(designsPath, designFileName);
+    const designFilePath = path64.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -30253,7 +30777,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path63 from "node:path";
+import path65 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -30305,7 +30829,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path63.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path65.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync5 } = await import("node:child_process");
     try {
@@ -30323,7 +30847,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path63.join(snapshotsPath, "history.json");
+      const snapshotFile = path65.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -30363,8 +30887,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path63.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path63.join(snapshotsPath, "history.json");
+    const snapshotsPath = path65.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path65.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -30423,8 +30947,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path63.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path63.join(snapshotsPath, "history.json");
+    const snapshotsPath = path65.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path65.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -30627,8 +31151,8 @@ ${chalk16.cyan("Performance Report")} ${chalk16.dim(`(last ${days} days)`)}`);
 });
 
 // core/commands/setup.ts
-import fs56 from "node:fs/promises";
-import path64 from "node:path";
+import fs58 from "node:fs/promises";
+import path66 from "node:path";
 import chalk17 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -30757,7 +31281,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path64.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path66.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -30815,11 +31339,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          await fs56.writeFile(statusLinePath, scriptContent, { mode: 493 });
+          await fs58.writeFile(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
           if (await fileExists(settingsPath)) {
             try {
-              settings = JSON.parse(await fs56.readFile(settingsPath, "utf8"));
+              settings = JSON.parse(await fs58.readFile(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -30827,7 +31351,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          await fs56.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+          await fs58.writeFile(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: getErrorMessage2(error) };
@@ -30883,18 +31407,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path65 from "node:path";
+import path67 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(path65.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists2(path65.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists2(path65.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists2(path65.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists2(path65.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists2(path67.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists2(path67.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists2(path67.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists2(path67.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists2(path67.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -30910,7 +31434,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path65.join(projectPath, "package.json");
+  const pkgPath = path67.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -30927,27 +31451,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists2(path65.join(projectPath, "pytest.ini"))) {
+  if (await fileExists2(path67.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path65.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path67.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists2(path65.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists2(path67.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists2(path65.join(projectPath, "go.mod"))) {
+  if (await fileExists2(path67.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(path65.join(projectPath, "pom.xml"))) {
+  if (await fileExists2(path67.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists2(path65.join(projectPath, "gradlew")) && (await fileExists2(path65.join(projectPath, "build.gradle")) || await fileExists2(path65.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists2(path67.join(projectPath, "gradlew")) && (await fileExists2(path67.join(projectPath, "build.gradle")) || await fileExists2(path67.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -30964,8 +31488,8 @@ var init_project_commands = __esm({
 });
 
 // core/workflow/workflow-preferences.ts
-import { exec as exec17 } from "node:child_process";
-import { promisify as promisify18 } from "node:util";
+import { exec as exec18 } from "node:child_process";
+import { promisify as promisify19 } from "node:util";
 import chalk18 from "chalk";
 function prefKey(hook, command) {
   return `workflow:${hook}_${command}`;
@@ -31108,7 +31632,7 @@ var init_workflow_preferences = __esm({
     init_memory_system();
     init_constants();
     init_fs();
-    execAsync12 = promisify18(exec17);
+    execAsync12 = promisify19(exec18);
     sessionPreferences = /* @__PURE__ */ new Map();
     oncePreferences = /* @__PURE__ */ new Map();
     __name(prefKey, "prefKey");
@@ -31122,7 +31646,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path66 from "node:path";
+import path68 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -31268,7 +31792,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path66.join(projectPath, "package.json");
+          const pkgPath = path68.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);
@@ -31290,7 +31814,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path66.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path68.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())}
 
@@ -31538,8 +32062,8 @@ var init_cache2 = __esm({
 });
 
 // core/utils/keychain.ts
-import { exec as exec18 } from "node:child_process";
-import { promisify as promisify19 } from "node:util";
+import { exec as exec19 } from "node:child_process";
+import { promisify as promisify20 } from "node:util";
 async function getCredential(key) {
   if (process.platform !== "darwin") {
     return getEnvFallback(key);
@@ -31566,7 +32090,7 @@ var init_keychain = __esm({
   "core/utils/keychain.ts"() {
     "use strict";
     init_fs();
-    execAsync13 = promisify19(exec18);
+    execAsync13 = promisify20(exec19);
     SERVICE_NAME = "prjct-cli";
     __name(getCredential, "getCredential");
     __name(getEnvFallback, "getEnvFallback");
@@ -32334,11 +32858,11 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs57 from "node:fs/promises";
+import fs59 from "node:fs/promises";
 import os19 from "node:os";
-import path67 from "node:path";
+import path69 from "node:path";
 function getCredentialsPath(projectId) {
-  return path67.join(os19.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path69.join(os19.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
@@ -32346,7 +32870,7 @@ async function getProjectCredentials(projectId) {
     return {};
   }
   try {
-    return JSON.parse(await fs57.readFile(credPath, "utf-8"));
+    return JSON.parse(await fs59.readFile(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", getErrorMessage2(error));
     return {};
@@ -33018,7 +33542,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.16.0",
+      version: "1.17.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -33125,7 +33649,7 @@ var require_package = __commonJS({
 // core/index.ts
 var core_exports = {};
 import os20 from "node:os";
-import path68 from "node:path";
+import path70 from "node:path";
 import chalk20 from "chalk";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
@@ -33338,13 +33862,13 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 async function displayVersion(version) {
   const detection = await detectAllProviders();
-  const claudeCommandPath = path68.join(os20.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path68.join(os20.homedir(), ".gemini", "commands", "p.toml");
+  const claudeCommandPath = path70.join(os20.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path70.join(os20.homedir(), ".gemini", "commands", "p.toml");
   const [claudeConfigured, geminiConfigured, cursorConfigured, cursorExists] = await Promise.all([
     fileExists(claudeCommandPath),
     fileExists(geminiCommandPath),
-    fileExists(path68.join(process.cwd(), ".cursor", "commands", "sync.md")),
-    fileExists(path68.join(process.cwd(), ".cursor"))
+    fileExists(path70.join(process.cwd(), ".cursor", "commands", "sync.md")),
+    fileExists(path70.join(process.cwd(), ".cursor"))
   ]);
   const antigravityDetection = await detectAntigravity();
   console.log(`
@@ -33483,7 +34007,7 @@ init_ai_provider();
 init_config_manager();
 init_editors_config();
 import os21 from "node:os";
-import path69 from "node:path";
+import path71 from "node:path";
 import chalk21 from "chalk";
 
 // core/server/server.ts
@@ -34304,13 +34828,13 @@ async function checkRoutersInstalled() {
   const home = os21.homedir();
   const detection = await detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path69.join(home, ".claude", "commands", "p.md");
+    const claudeRouter = path71.join(home, ".claude", "commands", "p.md");
     if (!await fileExists(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path69.join(home, ".gemini", "commands", "p.toml");
+    const geminiRouter = path71.join(home, ".gemini", "commands", "p.toml");
     if (!await fileExists(geminiRouter)) {
       return false;
     }
@@ -34451,7 +34975,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path69.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path71.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -34478,12 +35002,12 @@ if (args[0] === "start" || args[0] === "setup") {
     windsurfDetected,
     windsurfConfigured
   ] = await Promise.all([
-    fileExists(path69.join(home, ".claude", "commands", "p.md")),
-    fileExists(path69.join(home, ".gemini", "commands", "p.toml")),
-    fileExists(path69.join(cwd, ".cursor")),
-    fileExists(path69.join(cwd, ".cursor", "rules", "prjct.mdc")),
-    fileExists(path69.join(cwd, ".windsurf")),
-    fileExists(path69.join(cwd, ".windsurf", "rules", "prjct.md"))
+    fileExists(path71.join(home, ".claude", "commands", "p.md")),
+    fileExists(path71.join(home, ".gemini", "commands", "p.toml")),
+    fileExists(path71.join(cwd, ".cursor")),
+    fileExists(path71.join(cwd, ".cursor", "rules", "prjct.mdc")),
+    fileExists(path71.join(cwd, ".windsurf")),
+    fileExists(path71.join(cwd, ".windsurf", "rules", "prjct.md"))
   ]);
   console.log(`
 ${chalk21.cyan("p/")} prjct v${VERSION}
@@ -34522,7 +35046,7 @@ ${chalk21.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
 ${chalk21.cyan("https://prjct.app")}
 `);
 } else {
-  const configPath = path69.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path71.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = await checkRoutersInstalled();
   if (!await fileExists(configPath) || !routersInstalled) {
     console.log(`