prjct-cli 1.17.0 → 1.18.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) => (path72) => {
-  var fn = map[path72];
+var __glob = (map) => (path73) => {
+  var fn = map[path73];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path72);
+  throw new Error("Module not found in bundle: " + path73);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -6576,11 +6576,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs60 = await import("node:fs/promises");
-  const path72 = await import("node:path");
-  const fullPath = path72.isAbsolute(filePath) ? filePath : path72.join(projectPath, filePath);
+  const fs61 = await import("node:fs/promises");
+  const path73 = await import("node:path");
+  const fullPath = path73.isAbsolute(filePath) ? filePath : path73.join(projectPath, filePath);
   try {
-    const stat = await fs60.stat(fullPath);
+    const stat = await fs61.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -6647,11 +6647,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs60 = await import("node:fs/promises");
-  const path72 = await import("node:path");
-  const fullPath = path72.isAbsolute(targetPath) ? targetPath : path72.join(projectPath, targetPath);
+  const fs61 = await import("node:fs/promises");
+  const path73 = await import("node:path");
+  const fullPath = path73.isAbsolute(targetPath) ? targetPath : path73.join(projectPath, targetPath);
   try {
-    const stat = await fs60.stat(fullPath);
+    const stat = await fs61.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -21768,16 +21768,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs60 = await import("node:fs/promises");
-        const path72 = await import("node:path");
+        const fs61 = await import("node:fs/promises");
+        const path73 = await import("node:path");
         try {
-          const files = await fs60.readdir(this.projectPath);
+          const files = await fs61.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 = path72.join(this.projectPath, "package.json");
-            const pkgContent = await fs60.readFile(pkgPath, "utf-8");
+            const pkgPath = path73.join(this.projectPath, "package.json");
+            const pkgContent = await fs61.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -21813,32 +21813,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs60 = await import("node:fs/promises");
-        const path72 = await import("node:path");
+        const fs61 = await import("node:fs/promises");
+        const path73 = await import("node:path");
         const os22 = await import("node:os");
         const agents = [];
         try {
-          await fs60.access(path72.join(os22.homedir(), ".claude"));
+          await fs61.access(path73.join(os22.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs60.access(path72.join(this.projectPath, ".cursorrules"));
+          await fs61.access(path73.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs60.access(path72.join(this.projectPath, ".windsurfrules"));
+          await fs61.access(path73.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs60.access(path72.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs61.access(path73.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs60.access(path72.join(os22.homedir(), ".gemini"));
+          await fs61.access(path73.join(os22.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -21848,17 +21848,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs60 = await import("node:fs/promises");
-        const path72 = await import("node:path");
+        const fs61 = await import("node:fs/promises");
+        const path73 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs60.readdir(this.projectPath);
+          const files = await fs61.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path72.join(this.projectPath, "package.json");
-            const pkgContent = await fs60.readFile(pkgPath, "utf-8");
+            const pkgPath = path73.join(this.projectPath, "package.json");
+            const pkgContent = await fs61.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -22984,7 +22984,10 @@ var init_analysis2 = __esm({
             if (!isNonInteractive) {
               output_default.spin("Analyzing changes...");
             }
-            const result2 = await syncService.sync(projectPath, { aiTools: options.aiTools });
+            const result2 = await syncService.sync(projectPath, {
+              aiTools: options.aiTools,
+              full: options.full
+            });
             if (!result2.success) {
               if (isNonInteractive) {
                 console.log(JSON.stringify({ success: false, error: result2.error || "Sync failed" }));
@@ -23098,7 +23101,10 @@ ${formatFullDiff(diff)}`);
             return this.showSyncResult(result2, startTime);
           }
           output_default.spin("Syncing project...");
-          const result = await syncService.sync(projectPath, { aiTools: options.aiTools });
+          const result = await syncService.sync(projectPath, {
+            aiTools: options.aiTools,
+            full: options.full
+          });
           if (!result.success) {
             output_default.fail(result.error || "Sync failed");
             return { success: false, error: result.error };
@@ -24083,8 +24089,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path45.join(globalPath2, "planning", "specs");
             try {
-              const fs60 = await import("node:fs/promises");
-              const files = await fs60.readdir(specsPath2);
+              const fs61 = await import("node:fs/promises");
+              const files = await fs61.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -25283,109 +25289,6 @@ var init_bm25 = __esm({
   }
 });
 
-// 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";
@@ -25483,14 +25386,17 @@ async function buildGraph(projectPath) {
   };
 }
 function saveGraph(projectId, graph) {
-  database_default.setDoc(projectId, INDEX_KEY3, graph);
+  database_default.setDoc(projectId, INDEX_KEY2, graph);
+}
+function loadGraph(projectId) {
+  return database_default.getDoc(projectId, INDEX_KEY2);
 }
 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 INDEXABLE_EXTENSIONS2, SKIP_DIRS2, RESOLVE_EXTENSIONS, IMPORT_REGEX, INDEX_KEY2;
 var init_import_graph = __esm({
   "core/domain/import-graph.ts"() {
     "use strict";
@@ -25514,15 +25420,362 @@ var init_import_graph = __esm({
     __name(resolveImport2, "resolveImport");
     __name(listFiles3, "listFiles");
     __name(buildGraph, "buildGraph");
-    INDEX_KEY3 = "import-graph";
+    INDEX_KEY2 = "import-graph";
     __name(saveGraph, "saveGraph");
+    __name(loadGraph, "loadGraph");
     __name(indexImports, "indexImports");
   }
 });
 
-// core/services/context-generator.ts
+// core/domain/change-propagator.ts
+function propagateChanges(diff, projectId) {
+  const directlyChanged = [...diff.added, ...diff.modified];
+  const directSet = new Set(directlyChanged);
+  const affected = /* @__PURE__ */ new Set();
+  const graph = loadGraph(projectId);
+  if (graph) {
+    for (const changedFile of directlyChanged) {
+      const importers = graph.reverse[changedFile];
+      if (importers) {
+        for (const importer of importers) {
+          if (!directSet.has(importer)) {
+            affected.add(importer);
+          }
+        }
+      }
+    }
+  }
+  const affectedByImports = Array.from(affected);
+  const allAffected = [...directlyChanged, ...affectedByImports];
+  return {
+    directlyChanged,
+    affectedByImports,
+    deleted: diff.deleted,
+    allAffected
+  };
+}
+function affectedDomains(changedFiles) {
+  const domains = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    const lower = file.toLowerCase();
+    if (lower.endsWith(".tsx") || lower.endsWith(".jsx") || lower.endsWith(".css") || lower.endsWith(".scss") || lower.endsWith(".vue") || lower.endsWith(".svelte") || lower.includes("/components/") || lower.includes("/pages/") || lower.includes("/app/")) {
+      domains.add("frontend");
+      domains.add("uxui");
+    }
+    if (lower.includes(".test.") || lower.includes(".spec.") || lower.includes("__tests__") || lower.includes("/test/")) {
+      domains.add("testing");
+    }
+    if (lower.includes("dockerfile") || lower.includes("docker-compose") || lower.includes(".dockerignore") || lower.includes(".github/") || lower.includes("ci/") || lower.includes("cd/")) {
+      domains.add("devops");
+    }
+    if (lower.endsWith(".sql") || lower.includes("prisma") || lower.includes("drizzle") || lower.includes("migration") || lower.includes("/db/")) {
+      domains.add("database");
+    }
+    if ((lower.endsWith(".ts") || lower.endsWith(".js")) && !lower.includes(".test.") && !lower.includes(".spec.") && !lower.endsWith(".d.ts")) {
+      domains.add("backend");
+    }
+  }
+  return domains;
+}
+var init_change_propagator = __esm({
+  "core/domain/change-propagator.ts"() {
+    "use strict";
+    init_import_graph();
+    __name(propagateChanges, "propagateChanges");
+    __name(affectedDomains, "affectedDomains");
+  }
+});
+
+// core/domain/file-hasher.ts
 import fs48 from "node:fs/promises";
 import path51 from "node:path";
+async function listProjectFiles(dir, projectPath) {
+  const files = [];
+  const entries = await fs48.readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    const name = String(entry.name);
+    if (SKIP_DIRS3.has(name)) continue;
+    if (name.startsWith(".") && name !== ".env.example") continue;
+    const fullPath = path51.join(dir, name);
+    if (entry.isDirectory()) {
+      files.push(...await listProjectFiles(fullPath, projectPath));
+    } else if (entry.isFile()) {
+      const ext = path51.extname(name).toLowerCase();
+      if (INDEXABLE_EXTENSIONS3.has(ext)) {
+        files.push(path51.relative(projectPath, fullPath));
+      }
+    }
+  }
+  return files;
+}
+function hashContent(content) {
+  if (typeof Bun !== "undefined" && Bun.hash) {
+    return `xxh64:${Bun.hash(content).toString(36)}`;
+  }
+  let h = 2166136261;
+  for (let i = 0; i < content.length; i++) {
+    h ^= content.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `fnv1a:${(h >>> 0).toString(36)}`;
+}
+async function computeHashes(projectPath) {
+  const filePaths = await listProjectFiles(projectPath, projectPath);
+  const hashes = /* @__PURE__ */ new Map();
+  const BATCH_SIZE = 100;
+  for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
+    const batch = filePaths.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map(async (filePath) => {
+        try {
+          const fullPath = path51.join(projectPath, filePath);
+          const [content, stat] = await Promise.all([
+            fs48.readFile(fullPath, "utf-8"),
+            fs48.stat(fullPath)
+          ]);
+          return {
+            path: filePath,
+            hash: hashContent(content),
+            size: stat.size,
+            mtime: stat.mtime.toISOString()
+          };
+        } catch {
+          return null;
+        }
+      })
+    );
+    for (const result of results) {
+      if (result) {
+        hashes.set(result.path, result);
+      }
+    }
+  }
+  return hashes;
+}
+function diffHashes(current, stored) {
+  const added = [];
+  const modified = [];
+  const unchanged = [];
+  for (const [filePath, currentHash] of current) {
+    const storedHash = stored.get(filePath);
+    if (!storedHash) {
+      added.push(filePath);
+    } else if (storedHash.hash !== currentHash.hash) {
+      modified.push(filePath);
+    } else {
+      unchanged.push(filePath);
+    }
+  }
+  const deleted = [];
+  for (const filePath of stored.keys()) {
+    if (!current.has(filePath)) {
+      deleted.push(filePath);
+    }
+  }
+  return { added, modified, deleted, unchanged };
+}
+function saveHashes(projectId, hashes) {
+  const db = database_default.getDb(projectId);
+  db.transaction(() => {
+    db.prepare("DELETE FROM index_checksums").run();
+    const insert = db.prepare(
+      "INSERT INTO index_checksums (path, checksum, size, mtime) VALUES (?, ?, ?, ?)"
+    );
+    for (const [, hash] of hashes) {
+      insert.run(hash.path, hash.hash, hash.size, hash.mtime);
+    }
+  })();
+  database_default.setDoc(projectId, "file-hashes-meta", {
+    fileCount: hashes.size,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function loadHashes(projectId) {
+  const hashes = /* @__PURE__ */ new Map();
+  try {
+    const rows = database_default.query(
+      projectId,
+      "SELECT path, checksum, size, mtime FROM index_checksums"
+    );
+    for (const row of rows) {
+      hashes.set(row.path, {
+        path: row.path,
+        hash: row.checksum,
+        size: row.size || 0,
+        mtime: row.mtime || ""
+      });
+    }
+  } catch {
+  }
+  return hashes;
+}
+async function detectChanges(projectPath, projectId) {
+  const [currentHashes, storedHashes] = await Promise.all([
+    computeHashes(projectPath),
+    Promise.resolve(loadHashes(projectId))
+  ]);
+  const diff = diffHashes(currentHashes, storedHashes);
+  return { diff, currentHashes };
+}
+function hasHashRegistry(projectId) {
+  return database_default.hasDoc(projectId, "file-hashes-meta");
+}
+var INDEXABLE_EXTENSIONS3, SKIP_DIRS3;
+var init_file_hasher = __esm({
+  "core/domain/file-hasher.ts"() {
+    "use strict";
+    init_database();
+    INDEXABLE_EXTENSIONS3 = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".json",
+      ".md",
+      ".css",
+      ".scss",
+      ".html",
+      ".vue",
+      ".svelte",
+      ".py",
+      ".go",
+      ".rs",
+      ".yaml",
+      ".yml",
+      ".toml"
+    ]);
+    SKIP_DIRS3 = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      "coverage",
+      ".cache",
+      ".turbo",
+      ".vercel",
+      ".prjct"
+    ]);
+    __name(listProjectFiles, "listProjectFiles");
+    __name(hashContent, "hashContent");
+    __name(computeHashes, "computeHashes");
+    __name(diffHashes, "diffHashes");
+    __name(saveHashes, "saveHashes");
+    __name(loadHashes, "loadHashes");
+    __name(detectChanges, "detectChanges");
+    __name(hasHashRegistry, "hasHashRegistry");
+  }
+});
+
+// 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_KEY3, 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_KEY3;
+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_KEY3 = "cochange-index";
+    __name(saveMatrix, "saveMatrix");
+    __name(indexCoChanges, "indexCoChanges");
+  }
+});
+
+// core/services/context-generator.ts
+import fs49 from "node:fs/promises";
+import path52 from "node:path";
 var ContextFileGenerator;
 var init_context_generator = __esm({
   "core/services/context-generator.ts"() {
@@ -25547,10 +25800,10 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs48.readFile(filePath, "utf-8");
+          const existingContent = await fs49.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
-            const filename = path51.basename(filePath);
+            const filename = path52.basename(filePath);
             console.warn(`\u26A0\uFE0F  ${filename} has invalid preserve blocks:`);
             for (const error of validation.errors) {
               console.warn(`   ${error}`);
@@ -25559,13 +25812,13 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs48.writeFile(filePath, finalContent, "utf-8");
+        await fs49.writeFile(filePath, finalContent, "utf-8");
       }
       /**
        * Generate all context files in parallel
        */
       async generate(git, stats, commands, agents, sources) {
-        const contextPath = path51.join(this.config.globalPath, "context");
+        const contextPath = path52.join(this.config.globalPath, "context");
         await Promise.all([
           this.generateClaudeMd(contextPath, git, stats, commands, agents, sources),
           this.generateNowMd(contextPath),
@@ -25665,7 +25918,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        const claudePath = path51.join(contextPath, "CLAUDE.md");
+        const claudePath = path52.join(contextPath, "CLAUDE.md");
         await this.writeWithPreservation(claudePath, content);
       }
       /**
@@ -25674,8 +25927,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path51.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs48.readFile(statePath, "utf-8"));
+          const statePath = path52.join(this.config.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs49.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -25691,7 +25944,7 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await this.writeWithPreservation(path51.join(contextPath, "now.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "now.md"), content);
       }
       /**
        * Generate next.md - task queue
@@ -25699,15 +25952,15 @@ Use \`p. task "description"\` to start working.
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path51.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs48.readFile(queuePath, "utf-8"));
+          const queuePath = path52.join(this.config.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs49.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(path51.join(contextPath, "next.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "next.md"), content);
       }
       /**
        * Generate ideas.md - captured ideas
@@ -25715,15 +25968,15 @@ ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}
       async generateIdeasMd(contextPath) {
         let ideas = { ideas: [] };
         try {
-          const ideasPath = path51.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs48.readFile(ideasPath, "utf-8"));
+          const ideasPath = path52.join(this.config.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs49.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(path51.join(contextPath, "ideas.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "ideas.md"), content);
       }
       /**
        * Generate shipped.md - completed features
@@ -25733,8 +25986,8 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
           shipped: []
         };
         try {
-          const shippedPath = path51.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs48.readFile(shippedPath, "utf-8"));
+          const shippedPath = path52.join(this.config.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs49.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -25743,7 +25996,7 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await this.writeWithPreservation(path51.join(contextPath, "shipped.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "shipped.md"), content);
       }
       // ==========================================================================
       // MONOREPO SUPPORT
@@ -25772,9 +26025,9 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
             commands,
             agents
           );
-          const claudePath = path51.join(pkg.path, "CLAUDE.md");
+          const claudePath = path52.join(pkg.path, "CLAUDE.md");
           await this.writeWithPreservation(claudePath, content);
-          generatedFiles.push(path51.relative(this.config.projectPath, claudePath));
+          generatedFiles.push(path52.relative(this.config.projectPath, claudePath));
         }
         return generatedFiles;
       }
@@ -25787,8 +26040,8 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
         let pkgVersion = stats.version;
         let pkgName = pkg.name;
         try {
-          const pkgJsonPath = path51.join(pkg.path, "package.json");
-          const pkgJson = JSON.parse(await fs48.readFile(pkgJsonPath, "utf-8"));
+          const pkgJsonPath = path52.join(pkg.path, "package.json");
+          const pkgJson = JSON.parse(await fs49.readFile(pkgJsonPath, "utf-8"));
           pkgVersion = pkgJson.version || stats.version;
           pkgName = pkgJson.name || pkg.name;
         } catch {
@@ -25853,8 +26106,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 });
 
 // core/services/local-state-generator.ts
-import fs49 from "node:fs/promises";
-import path52 from "node:path";
+import fs50 from "node:fs/promises";
+import path53 from "node:path";
 var LOCAL_STATE_FILENAME, LocalStateGenerator, localStateGenerator;
 var init_local_state_generator = __esm({
   "core/services/local-state-generator.ts"() {
@@ -25869,17 +26122,17 @@ var init_local_state_generator = __esm({
        * Generate .prjct-state.md in the project root
        */
       async generate(projectPath, state) {
-        const filePath = path52.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
         const content = this.toMarkdown(state);
-        await fs49.writeFile(filePath, content, "utf-8");
+        await fs50.writeFile(filePath, content, "utf-8");
       }
       /**
        * Remove local state file
        */
       async remove(projectPath) {
-        const filePath = path52.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs49.unlink(filePath);
+          await fs50.unlink(filePath);
         } catch (error) {
           if (!isNotFoundError(error)) throw error;
         }
@@ -25888,9 +26141,9 @@ var init_local_state_generator = __esm({
        * Check if local state file exists
        */
       async exists(projectPath) {
-        const filePath = path52.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs49.access(filePath);
+          await fs50.access(filePath);
           return true;
         } catch {
           return false;
@@ -25969,11 +26222,11 @@ var init_local_state_generator = __esm({
 });
 
 // core/services/skill-lock.ts
-import fs50 from "node:fs/promises";
+import fs51 from "node:fs/promises";
 import os14 from "node:os";
-import path53 from "node:path";
+import path54 from "node:path";
 function getLockFilePath() {
-  return path53.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
+  return path54.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
 }
 function createEmptyLockFile() {
   return {
@@ -25984,7 +26237,7 @@ function createEmptyLockFile() {
 }
 async function read() {
   try {
-    const content = await fs50.readFile(getLockFilePath(), "utf-8");
+    const content = await fs51.readFile(getLockFilePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return createEmptyLockFile();
@@ -25992,9 +26245,9 @@ async function read() {
 }
 async function write(lockFile) {
   const lockPath = getLockFilePath();
-  await fs50.mkdir(path53.dirname(lockPath), { recursive: true });
+  await fs51.mkdir(path54.dirname(lockPath), { recursive: true });
   lockFile.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs50.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
+  await fs51.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
 }
 async function addEntry(entry) {
   const lockFile = await read();
@@ -26047,14 +26300,14 @@ var init_skill_lock = __esm({
 
 // core/services/skill-installer.ts
 import { exec as execCallback8 } from "node:child_process";
-import fs51 from "node:fs/promises";
+import fs52 from "node:fs/promises";
 import os15 from "node:os";
-import path54 from "node:path";
+import path55 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("~") ? path54.join(os15.homedir(), source.slice(1)) : path54.resolve(source);
+    const resolvedPath = source.startsWith("~") ? path55.join(os15.homedir(), source.slice(1)) : path55.resolve(source);
     return {
       type: "local",
       localPath: resolvedPath,
@@ -26092,22 +26345,22 @@ function parseSource(source) {
 async function discoverSkills(dir) {
   const skills = [];
   try {
-    const rootSkill = path54.join(dir, "SKILL.md");
-    await fs51.access(rootSkill);
-    const dirName = path54.basename(dir);
+    const rootSkill = path55.join(dir, "SKILL.md");
+    await fs52.access(rootSkill);
+    const dirName = path55.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 = path54.basename(path54.dirname(filePath));
+    const name = path55.basename(path55.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 = path54.basename(path54.dirname(filePath));
+    const name = path55.basename(path55.dirname(filePath));
     if (!skills.some((s) => s.name === name)) {
       skills.push({ name, filePath });
     }
@@ -26143,16 +26396,16 @@ ${prjctBlock.join("\n")}
 ${content}`;
 }
 function getInstallDir() {
-  return path54.join(os15.homedir(), ".claude", "skills");
+  return path55.join(os15.homedir(), ".claude", "skills");
 }
 async function installSkillFile(sourcePath, name, source, sha) {
   const installDir = getInstallDir();
-  const targetDir = path54.join(installDir, name);
-  const targetPath = path54.join(targetDir, "SKILL.md");
-  const content = await fs51.readFile(sourcePath, "utf-8");
+  const targetDir = path55.join(installDir, name);
+  const targetPath = path55.join(targetDir, "SKILL.md");
+  const content = await fs52.readFile(sourcePath, "utf-8");
   const enrichedContent = injectSourceMetadata(content, source, sha);
-  await fs51.mkdir(targetDir, { recursive: true });
-  await fs51.writeFile(targetPath, enrichedContent, "utf-8");
+  await fs52.mkdir(targetDir, { recursive: true });
+  await fs52.writeFile(targetPath, enrichedContent, "utf-8");
   return {
     name,
     filePath: targetPath,
@@ -26169,7 +26422,7 @@ async function installFromGitHub(source) {
     );
     return result;
   }
-  const tmpDir = path54.join(os15.tmpdir(), `prjct-skill-${Date.now()}`);
+  const tmpDir = path55.join(os15.tmpdir(), `prjct-skill-${Date.now()}`);
   try {
     const cloneUrl = `https://github.com/${source.owner}/${source.repo}.git`;
     await exec15(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
@@ -26213,7 +26466,7 @@ async function installFromGitHub(source) {
     }
   } finally {
     try {
-      await fs51.rm(tmpDir, { recursive: true, force: true });
+      await fs52.rm(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -26223,14 +26476,14 @@ async function installFromLocal(source) {
   const result = { installed: [], skipped: [], errors: [] };
   const localPath = source.localPath;
   try {
-    await fs51.access(localPath);
+    await fs52.access(localPath);
   } catch {
     result.errors.push(`Local path not found: ${localPath}`);
     return result;
   }
-  const stat = await fs51.stat(localPath);
+  const stat = await fs52.stat(localPath);
   if (stat.isFile()) {
-    const name = path54.basename(path54.dirname(localPath));
+    const name = path55.basename(path55.dirname(localPath));
     try {
       const installed = await installSkillFile(localPath, name, source);
       const lockEntry = {
@@ -26270,14 +26523,14 @@ async function installFromLocal(source) {
 }
 async function remove(name) {
   const installDir = getInstallDir();
-  const subdirPath = path54.join(installDir, name);
+  const subdirPath = path55.join(installDir, name);
   try {
-    await fs51.rm(subdirPath, { recursive: true, force: true });
+    await fs52.rm(subdirPath, { recursive: true, force: true });
   } catch {
   }
-  const flatPath = path54.join(installDir, `${name}.md`);
+  const flatPath = path55.join(installDir, `${name}.md`);
   try {
-    await fs51.rm(flatPath, { force: true });
+    await fs52.rm(flatPath, { force: true });
   } catch {
   }
   return skillLock.removeEntry(name);
@@ -26325,8 +26578,8 @@ var init_skill_installer = __esm({
 });
 
 // core/services/stack-detector.ts
-import fs52 from "node:fs/promises";
-import path55 from "node:path";
+import fs53 from "node:fs/promises";
+import path56 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -26485,8 +26738,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path55.join(this.projectPath, "package.json");
-          const content = await fs52.readFile(pkgPath, "utf-8");
+          const pkgPath = path56.join(this.projectPath, "package.json");
+          const content = await fs53.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -26497,7 +26750,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs52.access(path55.join(this.projectPath, filename));
+          await fs53.access(path56.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -26509,8 +26762,8 @@ var init_stack_detector = __esm({
 
 // core/services/sync-verifier.ts
 import { exec as exec16 } from "node:child_process";
-import fs53 from "node:fs/promises";
-import path56 from "node:path";
+import fs54 from "node:fs/promises";
+import path57 from "node:path";
 import { promisify as promisify17 } from "node:util";
 var execAsync10, BUILTIN_CHECKS, SyncVerifier, syncVerifier;
 var init_sync_verifier = __esm({
@@ -26527,9 +26780,9 @@ var init_sync_verifier = __esm({
         const expected = ["context/CLAUDE.md"];
         const missing = [];
         for (const file of expected) {
-          const filePath = path56.join(globalPath, file);
+          const filePath = path57.join(globalPath, file);
           try {
-            await fs53.access(filePath);
+            await fs54.access(filePath);
           } catch {
             missing.push(file);
           }
@@ -26550,9 +26803,9 @@ var init_sync_verifier = __esm({
         const jsonFiles = ["storage/state.json"];
         const invalid = [];
         for (const file of jsonFiles) {
-          const filePath = path56.join(globalPath, file);
+          const filePath = path57.join(globalPath, file);
           try {
-            const content = await fs53.readFile(filePath, "utf-8");
+            const content = await fs54.readFile(filePath, "utf-8");
             JSON.parse(content);
           } catch (error) {
             if (!isNotFoundError(error)) {
@@ -26573,7 +26826,7 @@ var init_sync_verifier = __esm({
        */
       async noSensitiveData(globalPath) {
         const start = Date.now();
-        const contextDir = path56.join(globalPath, "context");
+        const contextDir = path57.join(globalPath, "context");
         const patterns = [
           /(?:api[_-]?key|apikey)\s*[:=]\s*['"][^'"]{10,}/i,
           /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{4,}/i,
@@ -26581,10 +26834,10 @@ var init_sync_verifier = __esm({
         ];
         const violations = [];
         try {
-          const files = await fs53.readdir(contextDir);
+          const files = await fs54.readdir(contextDir);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
-            const content = await fs53.readFile(path56.join(contextDir, file), "utf-8");
+            const content = await fs54.readFile(path57.join(contextDir, file), "utf-8");
             for (const pattern of patterns) {
               if (pattern.test(content)) {
                 violations.push(`${file}: potential sensitive data detected`);
@@ -26705,9 +26958,9 @@ var init_sync_verifier = __esm({
 
 // core/services/sync-service.ts
 import { exec as exec17 } from "node:child_process";
-import fs54 from "node:fs/promises";
+import fs55 from "node:fs/promises";
 import os16 from "node:os";
-import path57 from "node:path";
+import path58 from "node:path";
 import { promisify as promisify18 } from "node:util";
 var execAsync11, SyncService, syncService;
 var init_sync_service = __esm({
@@ -26715,6 +26968,8 @@ var init_sync_service = __esm({
     "use strict";
     init_ai_tools();
     init_bm25();
+    init_change_propagator();
+    init_file_hasher();
     init_git_cochange();
     init_import_graph();
     init_errors();
@@ -26794,20 +27049,80 @@ 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 isFullSync = options.full === true;
+          let incrementalInfo;
+          let shouldRebuildIndexes = true;
+          let shouldRegenerateAgents = true;
+          let changedDomains = /* @__PURE__ */ new Set();
+          if (!isFullSync && hasHashRegistry(this.projectId)) {
+            try {
+              const { diff, currentHashes } = await detectChanges(this.projectPath, this.projectId);
+              const totalChanged = diff.added.length + diff.modified.length + diff.deleted.length;
+              if (totalChanged === 0 && !options.changedFiles?.length) {
+                shouldRebuildIndexes = false;
+                shouldRegenerateAgents = false;
+                incrementalInfo = {
+                  isIncremental: true,
+                  filesChanged: 0,
+                  filesUnchanged: diff.unchanged.length,
+                  indexesRebuilt: false,
+                  agentsRegenerated: false,
+                  affectedDomains: []
+                };
+              } else {
+                const propagated = propagateChanges(diff, this.projectId);
+                changedDomains = affectedDomains(propagated.allAffected);
+                const sourceExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+                const hasSourceChanges = propagated.allAffected.some((f) => {
+                  const ext = f.substring(f.lastIndexOf("."));
+                  return sourceExtensions.has(ext);
+                });
+                shouldRebuildIndexes = hasSourceChanges;
+                const configChanged = propagated.directlyChanged.some(
+                  (f) => f === "package.json" || f === "tsconfig.json" || f.includes("Dockerfile") || f.includes("docker-compose")
+                );
+                shouldRegenerateAgents = configChanged;
+                incrementalInfo = {
+                  isIncremental: true,
+                  filesChanged: totalChanged,
+                  filesUnchanged: diff.unchanged.length,
+                  indexesRebuilt: shouldRebuildIndexes,
+                  agentsRegenerated: shouldRegenerateAgents,
+                  affectedDomains: Array.from(changedDomains)
+                };
+              }
+              saveHashes(this.projectId, currentHashes);
+            } catch (error) {
+              logger_default.debug("Incremental detection failed, falling back to full sync", {
+                error: getErrorMessage(error)
+              });
+            }
+          } else {
+            try {
+              const { currentHashes } = await detectChanges(this.projectPath, this.projectId);
+              saveHashes(this.projectId, currentHashes);
+            } catch (error) {
+              logger_default.debug("Hash computation failed (non-critical)", {
+                error: getErrorMessage(error)
+              });
+            }
           }
-          const agents = await this.generateAgents(stack, stats);
+          if (shouldRebuildIndexes) {
+            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 = shouldRegenerateAgents ? await this.generateAgents(stack, stats) : await this.loadExistingAgents();
           const skills = this.configureSkills(agents);
-          const skillsInstalled = await this.autoInstallSkills(agents);
+          const skillsInstalled = shouldRegenerateAgents ? await this.autoInstallSkills(agents) : [];
           const sources = this.buildSources(stats, commands);
           const contextFiles = await this.generateContextFiles(git, stats, commands, agents, sources);
           const projectContext = {
@@ -26875,7 +27190,8 @@ var init_sync_service = __esm({
               success: r.success
             })),
             syncMetrics,
-            verification
+            verification,
+            incremental: incrementalInfo
           };
         } catch (error) {
           return {
@@ -26901,7 +27217,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs54.mkdir(path57.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs55.mkdir(path58.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -26972,7 +27288,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path57.basename(this.projectPath),
+          name: path58.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -26989,8 +27305,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path57.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs54.readFile(pkgPath, "utf-8"));
+          const pkgPath = path58.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs55.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -27135,12 +27451,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path57.join(this.globalPath, "agents");
+        const agentsPath = path58.join(this.globalPath, "agents");
         try {
-          const files = await fs54.readdir(agentsPath);
+          const files = await fs55.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs54.unlink(path57.join(agentsPath, file));
+              await fs55.unlink(path58.join(agentsPath, file));
             }
           }
         } catch (error) {
@@ -27178,6 +27494,27 @@ var init_sync_service = __esm({
         }
         return agents;
       }
+      /**
+       * Load existing agent info from disk (for incremental sync when agents don't need regeneration).
+       * Reads the agents directory and returns metadata without regenerating files.
+       */
+      async loadExistingAgents() {
+        const agentsPath = path58.join(this.globalPath, "agents");
+        const agents = [];
+        try {
+          const files = await fs55.readdir(agentsPath);
+          const workflowNames = /* @__PURE__ */ new Set(["prjct-workflow", "prjct-planner", "prjct-shipper"]);
+          for (const file of files) {
+            if (!file.endsWith(".md")) continue;
+            const name = file.replace(".md", "");
+            const type = workflowNames.has(name) ? "workflow" : "domain";
+            agents.push({ name, type });
+          }
+        } catch {
+          return [];
+        }
+        return agents;
+      }
       /**
        * Resolve {{> partial-name }} includes in template content.
        * Loads partials from templates/subagents/.
@@ -27189,7 +27526,7 @@ var init_sync_service = __esm({
         let resolved = content;
         for (const match of matches) {
           const partialName = match[1];
-          const partialPath = path57.join(
+          const partialPath = path58.join(
             __dirname,
             "..",
             "..",
@@ -27198,7 +27535,7 @@ var init_sync_service = __esm({
             `${partialName}.md`
           );
           try {
-            const partialContent = await fs54.readFile(partialPath, "utf-8");
+            const partialContent = await fs55.readFile(partialPath, "utf-8");
             resolved = resolved.replace(match[0], partialContent.trim());
           } catch {
             resolved = resolved.replace(match[0], `<!-- partial "${partialName}" not found -->`);
@@ -27209,7 +27546,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path57.join(
+          const templatePath = path58.join(
             __dirname,
             "..",
             "..",
@@ -27218,7 +27555,7 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs54.readFile(templatePath, "utf-8");
+          content = await fs55.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
         } catch (error) {
           logger_default.debug("Workflow agent template not found, generating minimal", {
@@ -27227,12 +27564,12 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs54.writeFile(path57.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs55.writeFile(path58.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path57.join(
+          const templatePath = path58.join(
             __dirname,
             "..",
             "..",
@@ -27241,7 +27578,7 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs54.readFile(templatePath, "utf-8");
+          content = await fs55.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
@@ -27253,7 +27590,7 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs54.writeFile(path57.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs55.writeFile(path58.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -27321,8 +27658,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]))
         };
-        fs54.writeFile(
-          path57.join(this.globalPath, "config", "skills.json"),
+        fs55.writeFile(
+          path58.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch((error) => {
@@ -27340,7 +27677,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       async autoInstallSkills(agents) {
         const results = [];
         try {
-          const mappingsPath = path57.join(
+          const mappingsPath = path58.join(
             __dirname,
             "..",
             "..",
@@ -27348,7 +27685,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
             "config",
             "skill-mappings.json"
           );
-          const mappingsContent = await fs54.readFile(mappingsPath, "utf-8");
+          const mappingsContent = await fs55.readFile(mappingsPath, "utf-8");
           const mappings = JSON.parse(mappingsContent);
           const agentToSkillMap = mappings.agentToSkillMap || {};
           const packagesToInstall = [];
@@ -27361,18 +27698,18 @@ You are the ${name} expert for this project. Apply best practices for the detect
             }
           }
           if (packagesToInstall.length === 0) return results;
-          const skillsDir = path57.join(os16.homedir(), ".claude", "skills");
+          const skillsDir = path58.join(os16.homedir(), ".claude", "skills");
           for (const { pkg, agent } of packagesToInstall) {
             const skillName = pkg.split("/").pop() || pkg;
-            const subdirPath = path57.join(skillsDir, skillName, "SKILL.md");
-            const flatPath = path57.join(skillsDir, `${skillName}.md`);
+            const subdirPath = path58.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path58.join(skillsDir, `${skillName}.md`);
             let alreadyInstalled = false;
             try {
-              await fs54.access(subdirPath);
+              await fs55.access(subdirPath);
               alreadyInstalled = true;
             } catch {
               try {
-                await fs54.access(flatPath);
+                await fs55.access(flatPath);
                 alreadyInstalled = true;
               } catch {
               }
@@ -27424,10 +27761,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path57.join(this.globalPath, "project.json");
+        const projectJsonPath = path58.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs54.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs55.readFile(projectJsonPath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing project.json", {
             path: projectJsonPath,
@@ -27453,16 +27790,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 fs54.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs55.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path57.join(this.globalPath, "storage", "state.json");
+        const statePath = path58.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs54.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs55.readFile(statePath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing state.json", { path: statePath, error: getErrorMessage(error) });
         }
@@ -27490,7 +27827,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 fs54.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs55.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
         try {
           await localStateGenerator.generate(
             this.projectPath,
@@ -27504,7 +27841,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path57.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path58.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: getTimestamp(),
           action: "sync",
@@ -27513,7 +27850,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs54.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs55.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -27533,8 +27870,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 = path57.join(this.globalPath, file);
-            const content = await fs54.readFile(filePath, "utf-8");
+            const filePath = path58.join(this.globalPath, file);
+            const content = await fs55.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Context file not found for metrics", { file, error: getErrorMessage(error) });
@@ -27542,8 +27879,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
         }
         for (const agent of agents) {
           try {
-            const agentPath = path57.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs54.readFile(agentPath, "utf-8");
+            const agentPath = path58.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs55.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Agent file not found for metrics", {
@@ -27605,7 +27942,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs54.access(path57.join(this.projectPath, filename));
+          await fs55.access(path58.join(this.projectPath, filename));
           return true;
         } catch (error) {
           logger_default.debug("File not found", { filename, error: getErrorMessage(error) });
@@ -27614,8 +27951,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path57.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs54.readFile(pkgPath, "utf-8"));
+          const pkgPath = path58.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs55.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch (error) {
           logger_default.debug("Failed to read CLI version", { error: getErrorMessage(error) });
@@ -27776,22 +28113,22 @@ __export(uninstall_exports, {
   uninstall: () => uninstall
 });
 import { execSync as execSync3 } from "node:child_process";
-import fs55 from "node:fs/promises";
+import fs56 from "node:fs/promises";
 import os17 from "node:os";
-import path58 from "node:path";
+import path59 from "node:path";
 import readline2 from "node:readline";
 import chalk12 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs55.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs56.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path58.join(dirPath, entry.name);
+      const entryPath = path59.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs55.stat(entryPath);
+          const stats = await fs56.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -27810,7 +28147,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs55.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs56.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -27843,7 +28180,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = await fileExists(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path58.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path59.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -27853,12 +28190,12 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path58.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path59.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = await fileExists(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
     try {
-      const content = await fs55.readFile(claudeMdPath, "utf-8");
+      const content = await fs56.readFile(claudeMdPath, "utf-8");
       hasPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -27887,7 +28224,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path58.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path59.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = await fileExists(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -27903,12 +28240,12 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path58.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path59.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = await fileExists(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
     try {
-      const content = await fs55.readFile(geminiMdPath, "utf-8");
+      const content = await fs56.readFile(geminiMdPath, "utf-8");
       hasGeminiPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -27925,7 +28262,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs55.readFile(filePath, "utf-8");
+    const content = await fs56.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -27934,9 +28271,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 fs55.unlink(filePath);
+      await fs56.unlink(filePath);
     } else {
-      await fs55.writeFile(filePath, `${newContent}
+      await fs56.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -27947,12 +28284,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 = path58.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path59.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs55.mkdir(backupDir, { recursive: true });
+    await fs56.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (await fileExists(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path58.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path59.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -27960,15 +28297,15 @@ async function createBackup3() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs55.mkdir(dest, { recursive: true });
-  const entries = await fs55.readdir(src, { withFileTypes: true });
+  await fs56.mkdir(dest, { recursive: true });
+  const entries = await fs56.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path58.join(src, entry.name);
-    const destPath = path58.join(dest, entry.name);
+    const srcPath = path59.join(src, entry.name);
+    const destPath = path59.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs55.copyFile(srcPath, destPath);
+      await fs56.copyFile(srcPath, destPath);
     }
   }
 }
@@ -27984,10 +28321,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs55.rm(item.path, { recursive: true, force: true });
+        await fs56.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs55.unlink(item.path);
+        await fs56.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -28164,7 +28501,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path59 from "node:path";
+import path60 from "node:path";
 import chalk13 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -28353,7 +28690,7 @@ ${chalk13.dim(`[${timestamp}]`)} ${chalk13.cyan("\u27F3")} ${filesSummary} chang
           );
         }
         try {
-          const result = await syncService.sync(this.projectPath);
+          const result = await syncService.sync(this.projectPath, { changedFiles });
           this.lastSyncTime = Date.now();
           this.syncCount++;
           if (result.success) {
@@ -28385,7 +28722,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: ${path59.basename(this.projectPath)}`));
+        console.log(chalk13.dim(`   Project: ${path60.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("");
@@ -28558,11 +28895,13 @@ var init_command_data = __esm({
         name: "sync",
         group: "core",
         description: "Sync project state and update workflow agents",
-        usage: { claude: "/p:sync", terminal: "prjct sync [--package=<name>]" },
+        usage: { claude: "/p:sync", terminal: "prjct sync [--package=<name>] [--full]" },
         implemented: true,
         hasTemplate: true,
         requiresProject: true,
         features: [
+          "Incremental sync: only re-analyzes changed files (default)",
+          "Force full sync: --full bypasses incremental cache",
           "Monorepo support: --package=<name> for single package sync",
           "Nested PRJCT.md inheritance",
           "Per-package CLAUDE.md generation"
@@ -29116,9 +29455,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync4 } from "node:child_process";
-import fs56 from "node:fs/promises";
+import fs57 from "node:fs/promises";
 import os18 from "node:os";
-import path60 from "node:path";
+import path61 from "node:path";
 import chalk15 from "chalk";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
@@ -29257,12 +29596,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    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 });
+    const geminiCommandsDir = path61.join(os18.homedir(), ".gemini", "commands");
+    const routerSource = path61.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
+    const routerDest = path61.join(geminiCommandsDir, "p.toml");
+    await fs57.mkdir(geminiCommandsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs56.copyFile(routerSource, routerDest);
+      await fs57.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -29273,15 +29612,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    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");
+    const geminiDir = path61.join(os18.homedir(), ".gemini");
+    const globalConfigPath = path61.join(geminiDir, "GEMINI.md");
+    const templatePath = path61.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
+    await fs57.mkdir(geminiDir, { recursive: true });
+    const templateContent = await fs57.readFile(templatePath, "utf-8");
     let existingContent = "";
     let configExists = false;
     try {
-      existingContent = await fs56.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs57.readFile(globalConfigPath, "utf-8");
       configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -29291,7 +29630,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!configExists) {
-      await fs56.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs57.writeFile(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -29301,7 +29640,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      await fs56.writeFile(globalConfigPath, updatedContent2, "utf-8");
+      await fs57.writeFile(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -29313,7 +29652,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    await fs56.writeFile(globalConfigPath, updatedContent, "utf-8");
+    await fs57.writeFile(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     logger_default.warn(`Gemini config warning: ${getErrorMessage2(error)}`);
@@ -29322,18 +29661,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    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 antigravitySkillsDir = path61.join(os18.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path61.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path61.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path61.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
+    await fs57.mkdir(prjctSkillDir, { recursive: true });
     const 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 fs56.readFile(templatePath, "utf-8");
-    await fs56.writeFile(skillMdPath, templateContent, "utf-8");
+    const templateContent = await fs57.readFile(templatePath, "utf-8");
+    await fs57.writeFile(skillMdPath, templateContent, "utf-8");
     return { success: true, action: skillExists ? "updated" : "created" };
   } catch (error) {
     logger_default.warn(`Antigravity skill warning: ${getErrorMessage2(error)}`);
@@ -29352,24 +29691,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    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 });
+    const cursorDir = path61.join(projectRoot, ".cursor");
+    const rulesDir = path61.join(cursorDir, "rules");
+    const commandsDir = path61.join(cursorDir, "commands");
+    const routerMdcDest = path61.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path61.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path61.join(PACKAGE_ROOT, "templates", "cursor", "commands");
+    await fs57.mkdir(rulesDir, { recursive: true });
+    await fs57.mkdir(commandsDir, { recursive: true });
     if (await fileExists(routerMdcSource)) {
-      await fs56.copyFile(routerMdcSource, routerMdcDest);
+      await fs57.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
     if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await fs56.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
+      const commandFiles = (await fs57.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path60.join(cursorCommandsSource, file);
-        const dest = path60.join(commandsDir, file);
-        await fs56.copyFile(src, dest);
+        const src = path61.join(cursorCommandsSource, file);
+        const dest = path61.join(commandsDir, file);
+        await fs57.copyFile(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -29383,7 +29722,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path60.join(projectRoot, ".gitignore");
+    const gitignorePath = path61.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -29398,7 +29737,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs56.readFile(gitignorePath, "utf-8");
+      content = await fs57.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -29413,7 +29752,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs56.writeFile(gitignorePath, newContent, "utf-8");
+    await fs57.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -29421,11 +29760,11 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasCursorProject(projectRoot) {
-  return await fileExists(path60.join(projectRoot, ".cursor"));
+  return await fileExists(path61.join(projectRoot, ".cursor"));
 }
 async function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path60.join(projectRoot, ".cursor");
-  const routerPath = path60.join(cursorDir, "rules", "prjct.mdc");
+  const cursorDir = path61.join(projectRoot, ".cursor");
+  const routerPath = path61.join(cursorDir, "rules", "prjct.mdc");
   return await fileExists(cursorDir) && !await fileExists(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
@@ -29436,26 +29775,26 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    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 });
+    const windsurfDir = path61.join(projectRoot, ".windsurf");
+    const rulesDir = path61.join(windsurfDir, "rules");
+    const workflowsDir = path61.join(windsurfDir, "workflows");
+    const routerDest = path61.join(rulesDir, "prjct.md");
+    const routerSource = path61.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path61.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
+    await fs57.mkdir(rulesDir, { recursive: true });
+    await fs57.mkdir(workflowsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs56.copyFile(routerSource, routerDest);
+      await fs57.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
     if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await fs56.readdir(windsurfWorkflowsSource)).filter(
+      const workflowFiles = (await fs57.readdir(windsurfWorkflowsSource)).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of workflowFiles) {
-        const src = path60.join(windsurfWorkflowsSource, file);
-        const dest = path60.join(workflowsDir, file);
-        await fs56.copyFile(src, dest);
+        const src = path61.join(windsurfWorkflowsSource, file);
+        const dest = path61.join(workflowsDir, file);
+        await fs57.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -29469,7 +29808,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path60.join(projectRoot, ".gitignore");
+    const gitignorePath = path61.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -29484,7 +29823,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs56.readFile(gitignorePath, "utf-8");
+      content = await fs57.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -29499,7 +29838,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs56.writeFile(gitignorePath, newContent, "utf-8");
+    await fs57.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -29507,32 +29846,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasWindsurfProject(projectRoot) {
-  return await fileExists(path60.join(projectRoot, ".windsurf"));
+  return await fileExists(path61.join(projectRoot, ".windsurf"));
 }
 async function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path60.join(projectRoot, ".windsurf");
-  const routerPath = path60.join(windsurfDir, "rules", "prjct.md");
+  const windsurfDir = path61.join(projectRoot, ".windsurf");
+  const routerPath = path61.join(windsurfDir, "rules", "prjct.md");
   return await fileExists(windsurfDir) && !await fileExists(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path60.join(os18.homedir(), ".prjct-cli", "projects");
+    const projectsDir = path61.join(os18.homedir(), ".prjct-cli", "projects");
     if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = (await fs56.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await fs57.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path60.join(projectsDir, projectId, "project.json");
+      const projectJsonPath = path61.join(projectsDir, projectId, "project.json");
       if (!await fileExists(projectJsonPath)) {
         continue;
       }
       try {
-        const content = await fs56.readFile(projectJsonPath, "utf8");
+        const content = await fs57.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          await fs56.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await fs57.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -29554,7 +29893,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
   if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(await fs56.readFile(settingsPath, "utf8"));
+      settings = JSON.parse(await fs57.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -29562,42 +29901,42 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  await fs56.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await fs57.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    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");
+    const claudeDir = path61.join(os18.homedir(), ".claude");
+    const settingsPath = path61.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path61.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path61.join(os18.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path61.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path61.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path61.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path61.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path61.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path61.join(PACKAGE_ROOT, "assets", "statusline");
+    const sourceScript = path61.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path61.join(assetsDir, "themes");
+    const sourceLibDir = path61.join(assetsDir, "lib");
+    const sourceComponentsDir = path61.join(assetsDir, "components");
+    const sourceConfigPath = path61.join(assetsDir, "default-config.json");
     if (!await fileExists(claudeDir)) {
-      await fs56.mkdir(claudeDir, { recursive: true });
+      await fs57.mkdir(claudeDir, { recursive: true });
     }
     if (!await fileExists(prjctStatusLineDir)) {
-      await fs56.mkdir(prjctStatusLineDir, { recursive: true });
+      await fs57.mkdir(prjctStatusLineDir, { recursive: true });
     }
     if (!await fileExists(prjctThemesDir)) {
-      await fs56.mkdir(prjctThemesDir, { recursive: true });
+      await fs57.mkdir(prjctThemesDir, { recursive: true });
     }
     if (!await fileExists(prjctLibDir)) {
-      await fs56.mkdir(prjctLibDir, { recursive: true });
+      await fs57.mkdir(prjctLibDir, { recursive: true });
     }
     if (!await fileExists(prjctComponentsDir)) {
-      await fs56.mkdir(prjctComponentsDir, { recursive: true });
+      await fs57.mkdir(prjctComponentsDir, { recursive: true });
     }
     if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await fs56.readFile(prjctStatusLinePath, "utf8");
+      const existingContent = await fs57.readFile(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -29605,7 +29944,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          await fs56.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await fs57.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         await installStatusLineModules(sourceLibDir, prjctLibDir);
         await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -29615,21 +29954,21 @@ async function installStatusLine() {
       }
     }
     if (await fileExists(sourceScript)) {
-      let scriptContent = await fs56.readFile(sourceScript, "utf8");
+      let scriptContent = await fs57.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await fs56.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs57.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
       await installStatusLineModules(sourceLibDir, prjctLibDir);
       await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
       if (await fileExists(sourceThemeDir)) {
-        const themes = await fs56.readdir(sourceThemeDir);
+        const themes = await fs57.readdir(sourceThemeDir);
         for (const theme of themes) {
-          const src = path60.join(sourceThemeDir, theme);
-          const dest = path60.join(prjctThemesDir, theme);
-          await fs56.copyFile(src, dest);
+          const src = path61.join(sourceThemeDir, theme);
+          const dest = path61.join(prjctThemesDir, theme);
+          await fs57.copyFile(src, dest);
         }
       }
       if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await fs56.copyFile(sourceConfigPath, prjctConfigPath);
+        await fs57.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -29664,7 +30003,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      await fs56.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs57.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -29676,10 +30015,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path60.join(os18.homedir(), ".claude");
-    const mcpConfigPath = path60.join(claudeDir, "mcp.json");
+    const claudeDir = path61.join(os18.homedir(), ".claude");
+    const mcpConfigPath = path61.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
-      await fs56.mkdir(claudeDir, { recursive: true });
+      await fs57.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -29690,16 +30029,16 @@ async function installContext7MCP() {
       }
     };
     if (await fileExists(mcpConfigPath)) {
-      const existingContent = await fs56.readFile(mcpConfigPath, "utf-8");
+      const existingContent = await fs57.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 fs56.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await fs57.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      await fs56.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      await fs57.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     logger_default.warn(`Context7 MCP setup warning: ${getErrorMessage2(error)}`);
@@ -29709,34 +30048,34 @@ async function installStatusLineModules(sourceDir, destDir) {
   if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = await fs56.readdir(sourceDir);
+  const files = await fs57.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path60.join(sourceDir, file);
-      const dest = path60.join(destDir, file);
-      await fs56.copyFile(src, dest);
-      await fs56.chmod(dest, 493);
+      const src = path61.join(sourceDir, file);
+      const dest = path61.join(destDir, file);
+      await fs57.copyFile(src, dest);
+      await fs57.chmod(dest, 493);
     }
   }
 }
 async function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
     if (await fileExists(linkPath)) {
-      const stats = await fs56.lstat(linkPath);
+      const stats = await fs57.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = await fs56.readlink(linkPath);
+        const existingTarget = await fs57.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      await fs56.unlink(linkPath);
+      await fs57.unlink(linkPath);
     }
-    await fs56.symlink(targetPath, linkPath);
+    await fs57.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
       if (await fileExists(targetPath)) {
-        await fs56.copyFile(targetPath, linkPath);
-        await fs56.chmod(linkPath, 493);
+        await fs57.copyFile(targetPath, linkPath);
+        await fs57.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -30151,7 +30490,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path61 from "node:path";
+import path62 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -30178,7 +30517,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path61.basename(projectPath);
+          const projectName = path62.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -30430,8 +30769,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs57 from "node:fs/promises";
-import path62 from "node:path";
+import fs58 from "node:fs/promises";
+import path63 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -30557,8 +30896,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path62.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs57.readFile(analysisPath, "utf-8");
+          const analysisPath = path63.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs58.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -30577,7 +30916,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path63 from "node:path";
+import path64 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -30593,7 +30932,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_exports.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path63.basename(filePath));
+          results.rotated.push(path64.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -30700,7 +31039,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path64 from "node:path";
+import path65 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -30712,7 +31051,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 = path64.join(
+    const designsPath = path65.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -30752,7 +31091,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path64.join(designsPath, designFileName);
+    const designFilePath = path65.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -30777,7 +31116,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path65 from "node:path";
+import path66 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -30829,7 +31168,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path65.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path66.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync5 } = await import("node:child_process");
     try {
@@ -30847,7 +31186,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path65.join(snapshotsPath, "history.json");
+      const snapshotFile = path66.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -30887,8 +31226,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path65.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path65.join(snapshotsPath, "history.json");
+    const snapshotsPath = path66.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path66.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -30947,8 +31286,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path65.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path65.join(snapshotsPath, "history.json");
+    const snapshotsPath = path66.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path66.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -31151,8 +31490,8 @@ ${chalk16.cyan("Performance Report")} ${chalk16.dim(`(last ${days} days)`)}`);
 });
 
 // core/commands/setup.ts
-import fs58 from "node:fs/promises";
-import path66 from "node:path";
+import fs59 from "node:fs/promises";
+import path67 from "node:path";
 import chalk17 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -31281,7 +31620,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path66.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path67.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -31339,11 +31678,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          await fs58.writeFile(statusLinePath, scriptContent, { mode: 493 });
+          await fs59.writeFile(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
           if (await fileExists(settingsPath)) {
             try {
-              settings = JSON.parse(await fs58.readFile(settingsPath, "utf8"));
+              settings = JSON.parse(await fs59.readFile(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -31351,7 +31690,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          await fs58.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+          await fs59.writeFile(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: getErrorMessage2(error) };
@@ -31407,18 +31746,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path67 from "node:path";
+import path68 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(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";
+  if (await fileExists2(path68.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists2(path68.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists2(path68.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists2(path68.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists2(path68.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -31434,7 +31773,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path67.join(projectPath, "package.json");
+  const pkgPath = path68.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -31451,27 +31790,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists2(path67.join(projectPath, "pytest.ini"))) {
+  if (await fileExists2(path68.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path67.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path68.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists2(path67.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists2(path68.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists2(path67.join(projectPath, "go.mod"))) {
+  if (await fileExists2(path68.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(path67.join(projectPath, "pom.xml"))) {
+  if (await fileExists2(path68.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists2(path67.join(projectPath, "gradlew")) && (await fileExists2(path67.join(projectPath, "build.gradle")) || await fileExists2(path67.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists2(path68.join(projectPath, "gradlew")) && (await fileExists2(path68.join(projectPath, "build.gradle")) || await fileExists2(path68.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -31646,7 +31985,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path68 from "node:path";
+import path69 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -31792,7 +32131,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path68.join(projectPath, "package.json");
+          const pkgPath = path69.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);
@@ -31814,7 +32153,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path68.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path69.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())}
 
@@ -32858,11 +33197,11 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs59 from "node:fs/promises";
+import fs60 from "node:fs/promises";
 import os19 from "node:os";
-import path69 from "node:path";
+import path70 from "node:path";
 function getCredentialsPath(projectId) {
-  return path69.join(os19.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path70.join(os19.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
@@ -32870,7 +33209,7 @@ async function getProjectCredentials(projectId) {
     return {};
   }
   try {
-    return JSON.parse(await fs59.readFile(credPath, "utf-8"));
+    return JSON.parse(await fs60.readFile(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", getErrorMessage2(error));
     return {};
@@ -33542,7 +33881,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.17.0",
+      version: "1.18.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -33649,7 +33988,7 @@ var require_package = __commonJS({
 // core/index.ts
 var core_exports = {};
 import os20 from "node:os";
-import path70 from "node:path";
+import path71 from "node:path";
 import chalk20 from "chalk";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
@@ -33754,7 +34093,8 @@ async function main() {
           preview: options.preview === true || options["dry-run"] === true,
           yes: options.yes === true,
           json: options.json === true,
-          package: options.package ? String(options.package) : void 0
+          package: options.package ? String(options.package) : void 0,
+          full: options.full === true
         }), "sync"),
         seal: /* @__PURE__ */ __name(() => commands.seal(process.cwd(), { json: options.json === true }), "seal"),
         verify: /* @__PURE__ */ __name(() => commands.verify(process.cwd(), { json: options.json === true }), "verify"),
@@ -33862,13 +34202,13 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 async function displayVersion(version) {
   const detection = await detectAllProviders();
-  const claudeCommandPath = path70.join(os20.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path70.join(os20.homedir(), ".gemini", "commands", "p.toml");
+  const claudeCommandPath = path71.join(os20.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path71.join(os20.homedir(), ".gemini", "commands", "p.toml");
   const [claudeConfigured, geminiConfigured, cursorConfigured, cursorExists] = await Promise.all([
     fileExists(claudeCommandPath),
     fileExists(geminiCommandPath),
-    fileExists(path70.join(process.cwd(), ".cursor", "commands", "sync.md")),
-    fileExists(path70.join(process.cwd(), ".cursor"))
+    fileExists(path71.join(process.cwd(), ".cursor", "commands", "sync.md")),
+    fileExists(path71.join(process.cwd(), ".cursor"))
   ]);
   const antigravityDetection = await detectAntigravity();
   console.log(`
@@ -34007,7 +34347,7 @@ init_ai_provider();
 init_config_manager();
 init_editors_config();
 import os21 from "node:os";
-import path71 from "node:path";
+import path72 from "node:path";
 import chalk21 from "chalk";
 
 // core/server/server.ts
@@ -34828,13 +35168,13 @@ async function checkRoutersInstalled() {
   const home = os21.homedir();
   const detection = await detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path71.join(home, ".claude", "commands", "p.md");
+    const claudeRouter = path72.join(home, ".claude", "commands", "p.md");
     if (!await fileExists(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path71.join(home, ".gemini", "commands", "p.toml");
+    const geminiRouter = path72.join(home, ".gemini", "commands", "p.toml");
     if (!await fileExists(geminiRouter)) {
       return false;
     }
@@ -34975,7 +35315,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path71.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path72.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -35002,12 +35342,12 @@ if (args[0] === "start" || args[0] === "setup") {
     windsurfDetected,
     windsurfConfigured
   ] = await Promise.all([
-    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"))
+    fileExists(path72.join(home, ".claude", "commands", "p.md")),
+    fileExists(path72.join(home, ".gemini", "commands", "p.toml")),
+    fileExists(path72.join(cwd, ".cursor")),
+    fileExists(path72.join(cwd, ".cursor", "rules", "prjct.mdc")),
+    fileExists(path72.join(cwd, ".windsurf")),
+    fileExists(path72.join(cwd, ".windsurf", "rules", "prjct.md"))
   ]);
   console.log(`
 ${chalk21.cyan("p/")} prjct v${VERSION}
@@ -35046,7 +35386,7 @@ ${chalk21.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
 ${chalk21.cyan("https://prjct.app")}
 `);
 } else {
-  const configPath = path71.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path72.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = await checkRoutersInstalled();
   if (!await fileExists(configPath) || !routersInstalled) {
     console.log(`