prjct-cli 1.16.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) => (path70) => {
-  var fn = map[path70];
+var __glob = (map) => (path73) => {
+  var fn = map[path73];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path70);
+  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;
@@ -4051,7 +4051,7 @@ var init_cache = __esm({
 import { Database } from "bun:sqlite";
 import fs15 from "node:fs";
 import path14 from "node:path";
-var migrations, PrjctDatabase, prjctDb;
+var migrations, PrjctDatabase, prjctDb, database_default;
 var init_database = __esm({
   "core/storage/database.ts"() {
     "use strict";
@@ -4482,6 +4482,7 @@ var init_database = __esm({
       }
     };
     prjctDb = new PrjctDatabase();
+    database_default = prjctDb;
   }
 });
 
@@ -6575,11 +6576,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs58 = await import("node:fs/promises");
-  const path70 = await import("node:path");
-  const fullPath = path70.isAbsolute(filePath) ? filePath : path70.join(projectPath, filePath);
+  const 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 fs58.stat(fullPath);
+    const stat = await fs61.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -6646,11 +6647,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs58 = await import("node:fs/promises");
-  const path70 = await import("node:path");
-  const fullPath = path70.isAbsolute(targetPath) ? targetPath : path70.join(projectPath, targetPath);
+  const 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 fs58.stat(fullPath);
+    const stat = await fs61.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -21767,16 +21768,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs58 = await import("node:fs/promises");
-        const path70 = await import("node:path");
+        const fs61 = await import("node:fs/promises");
+        const path73 = await import("node:path");
         try {
-          const files = await fs58.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 = path70.join(this.projectPath, "package.json");
-            const pkgContent = await fs58.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";
@@ -21812,32 +21813,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs58 = await import("node:fs/promises");
-        const path70 = await import("node:path");
+        const fs61 = await import("node:fs/promises");
+        const path73 = await import("node:path");
         const os22 = await import("node:os");
         const agents = [];
         try {
-          await fs58.access(path70.join(os22.homedir(), ".claude"));
+          await fs61.access(path73.join(os22.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs58.access(path70.join(this.projectPath, ".cursorrules"));
+          await fs61.access(path73.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs58.access(path70.join(this.projectPath, ".windsurfrules"));
+          await fs61.access(path73.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs58.access(path70.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs61.access(path73.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs58.access(path70.join(os22.homedir(), ".gemini"));
+          await fs61.access(path73.join(os22.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -21847,17 +21848,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs58 = await import("node:fs/promises");
-        const path70 = await import("node:path");
+        const fs61 = await import("node:fs/promises");
+        const path73 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs58.readdir(this.projectPath);
+          const files = await fs61.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path70.join(this.projectPath, "package.json");
-            const pkgContent = await fs58.readFile(pkgPath, "utf-8");
+            const pkgPath = 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";
@@ -22983,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" }));
@@ -23097,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 };
@@ -24082,8 +24089,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path45.join(globalPath2, "planning", "specs");
             try {
-              const fs58 = await import("node:fs/promises");
-              const files = await fs58.readdir(specsPath2);
+              const 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");
@@ -25010,9 +25017,765 @@ var init_ai_tools = __esm({
   }
 });
 
-// core/services/context-generator.ts
+// core/domain/bm25.ts
 import fs46 from "node:fs/promises";
 import path49 from "node:path";
+function splitIdentifier(identifier) {
+  return identifier.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[-_./]/g, " ").toLowerCase().split(/\s+/).filter((w) => w.length > 1);
+}
+function tokenizeFile(content, filePath) {
+  const tokens = [];
+  const pathParts = filePath.replace(/\.[^.]+$/, "").split(/[/\\]/).filter(Boolean);
+  for (const part of pathParts) {
+    tokens.push(...splitIdentifier(part));
+  }
+  const exportPatterns = [
+    /export\s+(?:async\s+)?function\s+(\w+)/g,
+    /export\s+class\s+(\w+)/g,
+    /export\s+interface\s+(\w+)/g,
+    /export\s+type\s+(\w+)/g,
+    /export\s+(?:const|let|var)\s+(\w+)/g,
+    /export\s+default\s+(?:class|function)\s+(\w+)/g
+  ];
+  for (const pattern of exportPatterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      if (match[1]) {
+        tokens.push(...splitIdentifier(match[1]));
+      }
+    }
+  }
+  const declPatterns = [
+    /(?:async\s+)?function\s+(\w+)/g,
+    /class\s+(\w+)/g,
+    /interface\s+(\w+)/g,
+    /type\s+(\w+)\s*=/g
+  ];
+  for (const pattern of declPatterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      if (match[1]) {
+        tokens.push(...splitIdentifier(match[1]));
+      }
+    }
+  }
+  const importPattern = /(?:from|import)\s+['"]([^'"]+)['"]/g;
+  let importMatch;
+  while ((importMatch = importPattern.exec(content)) !== null) {
+    const source = importMatch[1];
+    if (source.startsWith(".") || source.startsWith("@/")) {
+      tokens.push(...splitIdentifier(source));
+    } else {
+      const pkgName = source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+      tokens.push(...splitIdentifier(pkgName));
+    }
+  }
+  const singleLineComments = /\/\/\s*(.+)/g;
+  let commentMatch;
+  while ((commentMatch = singleLineComments.exec(content)) !== null) {
+    const words = commentMatch[1].toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    tokens.push(...words);
+  }
+  const multiLineComments = /\/\*\*?([\s\S]*?)\*\//g;
+  let multiMatch;
+  while ((multiMatch = multiLineComments.exec(content)) !== null) {
+    const words = multiMatch[1].replace(/@\w+/g, "").replace(/\*/g, "").toLowerCase().split(/\s+/).filter((w) => w.length > 2 && /^[a-z]+$/.test(w));
+    tokens.push(...words);
+  }
+  return tokens.filter((t) => t.length > 1 && !STOP_WORDS.has(t) && /^[a-z][a-z0-9]*$/.test(t));
+}
+async function listFiles2(dir, projectPath) {
+  const files = [];
+  const entries = await fs46.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const fullPath = path49.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles2(fullPath, projectPath));
+    } else if (entry.isFile()) {
+      const ext = path49.extname(entry.name).toLowerCase();
+      if (INDEXABLE_EXTENSIONS.has(ext)) {
+        files.push(path49.relative(projectPath, fullPath));
+      }
+    }
+  }
+  return files;
+}
+async function buildIndex(projectPath) {
+  const files = await listFiles2(projectPath, projectPath);
+  const documents = {};
+  const invertedIndex = {};
+  let totalLength = 0;
+  const BATCH_SIZE = 50;
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map(async (filePath) => {
+        try {
+          const content = await fs46.readFile(path49.join(projectPath, filePath), "utf-8");
+          const tokens = tokenizeFile(content, filePath);
+          return { filePath, tokens };
+        } catch {
+          return { filePath, tokens: [] };
+        }
+      })
+    );
+    for (const { filePath, tokens } of results) {
+      if (tokens.length === 0) continue;
+      documents[filePath] = { tokens, length: tokens.length };
+      totalLength += tokens.length;
+      const tfMap = /* @__PURE__ */ new Map();
+      for (const token of tokens) {
+        tfMap.set(token, (tfMap.get(token) || 0) + 1);
+      }
+      for (const [token, tf] of tfMap) {
+        if (!invertedIndex[token]) {
+          invertedIndex[token] = [];
+        }
+        invertedIndex[token].push({ path: filePath, tf });
+      }
+    }
+  }
+  const totalDocs = Object.keys(documents).length;
+  return {
+    documents,
+    invertedIndex,
+    avgDocLength: totalDocs > 0 ? totalLength / totalDocs : 0,
+    totalDocs,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function saveIndex(projectId, index) {
+  const storable = {
+    invertedIndex: index.invertedIndex,
+    avgDocLength: index.avgDocLength,
+    totalDocs: index.totalDocs,
+    builtAt: index.builtAt,
+    // Store document lengths (needed for scoring) but not full token lists
+    docLengths: Object.fromEntries(Object.entries(index.documents).map(([p, d]) => [p, d.length]))
+  };
+  database_default.setDoc(projectId, INDEX_KEY, storable);
+}
+async function indexProject(projectPath, projectId) {
+  const index = await buildIndex(projectPath);
+  saveIndex(projectId, index);
+  return index;
+}
+var INDEXABLE_EXTENSIONS, STOP_WORDS, SKIP_DIRS, INDEX_KEY;
+var init_bm25 = __esm({
+  "core/domain/bm25.ts"() {
+    "use strict";
+    init_database();
+    INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".go",
+      ".rs",
+      ".java",
+      ".cs",
+      ".rb",
+      ".php",
+      ".vue",
+      ".svelte"
+    ]);
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "shall",
+      "can",
+      "of",
+      "in",
+      "to",
+      "for",
+      "with",
+      "on",
+      "at",
+      "from",
+      "by",
+      "as",
+      "or",
+      "and",
+      "but",
+      "if",
+      "not",
+      "no",
+      "so",
+      "up",
+      "out",
+      "this",
+      "that",
+      "it",
+      "its",
+      "all",
+      "any",
+      // Code noise
+      "import",
+      "export",
+      "default",
+      "const",
+      "let",
+      "var",
+      "function",
+      "class",
+      "interface",
+      "type",
+      "return",
+      "new",
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "void",
+      "async",
+      "await",
+      "static",
+      "public",
+      "private",
+      "protected",
+      "readonly",
+      "string",
+      "number",
+      "boolean",
+      "object",
+      "array"
+    ]);
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      "coverage",
+      ".cache",
+      ".turbo",
+      ".vercel",
+      "__pycache__",
+      "vendor",
+      "target"
+    ]);
+    __name(splitIdentifier, "splitIdentifier");
+    __name(tokenizeFile, "tokenizeFile");
+    __name(listFiles2, "listFiles");
+    __name(buildIndex, "buildIndex");
+    INDEX_KEY = "bm25-index";
+    __name(saveIndex, "saveIndex");
+    __name(indexProject, "indexProject");
+  }
+});
+
+// core/domain/import-graph.ts
+import fs47 from "node:fs/promises";
+import path50 from "node:path";
+function extractImportSources(content) {
+  const sources = [];
+  let match;
+  const regex = new RegExp(IMPORT_REGEX.source, "g");
+  while ((match = regex.exec(content)) !== null) {
+    const source = match[1];
+    if (source.startsWith(".") || source.startsWith("@/")) {
+      sources.push(source);
+    }
+  }
+  return sources;
+}
+async function resolveImport2(source, fromFile, projectPath) {
+  let basePath;
+  if (source.startsWith("@/")) {
+    basePath = path50.join(projectPath, "src", source.slice(2));
+  } else {
+    const fromDir = path50.dirname(path50.join(projectPath, fromFile));
+    basePath = path50.resolve(fromDir, source);
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const fullPath = basePath + ext;
+    try {
+      const stat = await fs47.stat(fullPath);
+      if (stat.isFile()) {
+        return path50.relative(projectPath, fullPath);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function listFiles3(dir, projectPath) {
+  const files = [];
+  const entries = await fs47.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (SKIP_DIRS2.has(entry.name)) continue;
+    const fullPath = path50.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles3(fullPath, projectPath));
+    } else if (entry.isFile()) {
+      const ext = path50.extname(entry.name).toLowerCase();
+      if (INDEXABLE_EXTENSIONS2.has(ext)) {
+        files.push(path50.relative(projectPath, fullPath));
+      }
+    }
+  }
+  return files;
+}
+async function buildGraph(projectPath) {
+  const files = await listFiles3(projectPath, projectPath);
+  const forward = {};
+  const reverse = {};
+  let edgeCount = 0;
+  const BATCH_SIZE = 50;
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map(async (filePath) => {
+        try {
+          const content = await fs47.readFile(path50.join(projectPath, filePath), "utf-8");
+          const sources = extractImportSources(content);
+          const resolved = [];
+          for (const source of sources) {
+            const target = await resolveImport2(source, filePath, projectPath);
+            if (target && target !== filePath) {
+              resolved.push(target);
+            }
+          }
+          return { filePath, imports: resolved };
+        } catch {
+          return { filePath, imports: [] };
+        }
+      })
+    );
+    for (const { filePath, imports } of results) {
+      if (imports.length === 0) continue;
+      forward[filePath] = imports;
+      edgeCount += imports.length;
+      for (const target of imports) {
+        if (!reverse[target]) reverse[target] = [];
+        reverse[target].push(filePath);
+      }
+    }
+  }
+  return {
+    forward,
+    reverse,
+    fileCount: files.length,
+    edgeCount,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function saveGraph(projectId, graph) {
+  database_default.setDoc(projectId, INDEX_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_KEY2;
+var init_import_graph = __esm({
+  "core/domain/import-graph.ts"() {
+    "use strict";
+    init_database();
+    INDEXABLE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+    SKIP_DIRS2 = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      "coverage",
+      ".cache",
+      ".turbo",
+      ".vercel"
+    ]);
+    RESOLVE_EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"];
+    IMPORT_REGEX = /(?:import|from)\s+['"]([^'"]+)['"]/g;
+    __name(extractImportSources, "extractImportSources");
+    __name(resolveImport2, "resolveImport");
+    __name(listFiles3, "listFiles");
+    __name(buildGraph, "buildGraph");
+    INDEX_KEY2 = "import-graph";
+    __name(saveGraph, "saveGraph");
+    __name(loadGraph, "loadGraph");
+    __name(indexImports, "indexImports");
+  }
+});
+
+// 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"() {
@@ -25037,10 +25800,10 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs46.readFile(filePath, "utf-8");
+          const existingContent = await fs49.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
-            const filename = path49.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}`);
@@ -25049,13 +25812,13 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs46.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 = path49.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),
@@ -25155,7 +25918,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        const claudePath = path49.join(contextPath, "CLAUDE.md");
+        const claudePath = path52.join(contextPath, "CLAUDE.md");
         await this.writeWithPreservation(claudePath, content);
       }
       /**
@@ -25164,8 +25927,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path49.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs46.readFile(statePath, "utf-8"));
+          const statePath = path52.join(this.config.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs49.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -25181,7 +25944,7 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await this.writeWithPreservation(path49.join(contextPath, "now.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "now.md"), content);
       }
       /**
        * Generate next.md - task queue
@@ -25189,15 +25952,15 @@ Use \`p. task "description"\` to start working.
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path49.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs46.readFile(queuePath, "utf-8"));
+          const queuePath = 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(path49.join(contextPath, "next.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "next.md"), content);
       }
       /**
        * Generate ideas.md - captured ideas
@@ -25205,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 = path49.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs46.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(path49.join(contextPath, "ideas.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "ideas.md"), content);
       }
       /**
        * Generate shipped.md - completed features
@@ -25223,8 +25986,8 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
           shipped: []
         };
         try {
-          const shippedPath = path49.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs46.readFile(shippedPath, "utf-8"));
+          const shippedPath = path52.join(this.config.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs49.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -25233,7 +25996,7 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await this.writeWithPreservation(path49.join(contextPath, "shipped.md"), content);
+        await this.writeWithPreservation(path52.join(contextPath, "shipped.md"), content);
       }
       // ==========================================================================
       // MONOREPO SUPPORT
@@ -25262,9 +26025,9 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
             commands,
             agents
           );
-          const claudePath = path49.join(pkg.path, "CLAUDE.md");
+          const claudePath = path52.join(pkg.path, "CLAUDE.md");
           await this.writeWithPreservation(claudePath, content);
-          generatedFiles.push(path49.relative(this.config.projectPath, claudePath));
+          generatedFiles.push(path52.relative(this.config.projectPath, claudePath));
         }
         return generatedFiles;
       }
@@ -25277,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 = path49.join(pkg.path, "package.json");
-          const pkgJson = JSON.parse(await fs46.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 {
@@ -25343,8 +26106,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 });
 
 // core/services/local-state-generator.ts
-import fs47 from "node:fs/promises";
-import path50 from "node:path";
+import 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"() {
@@ -25359,17 +26122,17 @@ var init_local_state_generator = __esm({
        * Generate .prjct-state.md in the project root
        */
       async generate(projectPath, state) {
-        const filePath = path50.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
         const content = this.toMarkdown(state);
-        await fs47.writeFile(filePath, content, "utf-8");
+        await fs50.writeFile(filePath, content, "utf-8");
       }
       /**
        * Remove local state file
        */
       async remove(projectPath) {
-        const filePath = path50.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs47.unlink(filePath);
+          await fs50.unlink(filePath);
         } catch (error) {
           if (!isNotFoundError(error)) throw error;
         }
@@ -25378,9 +26141,9 @@ var init_local_state_generator = __esm({
        * Check if local state file exists
        */
       async exists(projectPath) {
-        const filePath = path50.join(projectPath, LOCAL_STATE_FILENAME);
+        const filePath = path53.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs47.access(filePath);
+          await fs50.access(filePath);
           return true;
         } catch {
           return false;
@@ -25459,11 +26222,11 @@ var init_local_state_generator = __esm({
 });
 
 // core/services/skill-lock.ts
-import fs48 from "node:fs/promises";
+import fs51 from "node:fs/promises";
 import os14 from "node:os";
-import path51 from "node:path";
+import path54 from "node:path";
 function getLockFilePath() {
-  return path51.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
+  return path54.join(os14.homedir(), ".prjct-cli", "skills", LOCK_FILE_NAME);
 }
 function createEmptyLockFile() {
   return {
@@ -25474,7 +26237,7 @@ function createEmptyLockFile() {
 }
 async function read() {
   try {
-    const content = await fs48.readFile(getLockFilePath(), "utf-8");
+    const content = await fs51.readFile(getLockFilePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return createEmptyLockFile();
@@ -25482,9 +26245,9 @@ async function read() {
 }
 async function write(lockFile) {
   const lockPath = getLockFilePath();
-  await fs48.mkdir(path51.dirname(lockPath), { recursive: true });
+  await fs51.mkdir(path54.dirname(lockPath), { recursive: true });
   lockFile.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs48.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();
@@ -25536,15 +26299,15 @@ var init_skill_lock = __esm({
 });
 
 // core/services/skill-installer.ts
-import { exec as execCallback7 } from "node:child_process";
-import fs49 from "node:fs/promises";
+import { exec as execCallback8 } from "node:child_process";
+import fs52 from "node:fs/promises";
 import os15 from "node:os";
-import path52 from "node:path";
-import { promisify as promisify15 } from "node:util";
+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("~") ? path52.join(os15.homedir(), source.slice(1)) : path52.resolve(source);
+    const resolvedPath = source.startsWith("~") ? path55.join(os15.homedir(), source.slice(1)) : path55.resolve(source);
     return {
       type: "local",
       localPath: resolvedPath,
@@ -25582,22 +26345,22 @@ function parseSource(source) {
 async function discoverSkills(dir) {
   const skills = [];
   try {
-    const rootSkill = path52.join(dir, "SKILL.md");
-    await fs49.access(rootSkill);
-    const dirName = path52.basename(dir);
+    const rootSkill = 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 = path52.basename(path52.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 = path52.basename(path52.dirname(filePath));
+    const name = path55.basename(path55.dirname(filePath));
     if (!skills.some((s) => s.name === name)) {
       skills.push({ name, filePath });
     }
@@ -25633,16 +26396,16 @@ ${prjctBlock.join("\n")}
 ${content}`;
 }
 function getInstallDir() {
-  return path52.join(os15.homedir(), ".claude", "skills");
+  return path55.join(os15.homedir(), ".claude", "skills");
 }
 async function installSkillFile(sourcePath, name, source, sha) {
   const installDir = getInstallDir();
-  const targetDir = path52.join(installDir, name);
-  const targetPath = path52.join(targetDir, "SKILL.md");
-  const content = await fs49.readFile(sourcePath, "utf-8");
+  const targetDir = 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 fs49.mkdir(targetDir, { recursive: true });
-  await fs49.writeFile(targetPath, enrichedContent, "utf-8");
+  await fs52.mkdir(targetDir, { recursive: true });
+  await fs52.writeFile(targetPath, enrichedContent, "utf-8");
   return {
     name,
     filePath: targetPath,
@@ -25659,13 +26422,13 @@ async function installFromGitHub(source) {
     );
     return result;
   }
-  const tmpDir = path52.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 exec14(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
+    await exec15(`git clone --depth 1 ${cloneUrl} ${tmpDir}`, { timeout: getTimeout("GIT_CLONE") });
     let sha;
     try {
-      const { stdout } = await exec14("git rev-parse HEAD", {
+      const { stdout } = await exec15("git rev-parse HEAD", {
         cwd: tmpDir,
         timeout: getTimeout("TOOL_CHECK")
       });
@@ -25703,7 +26466,7 @@ async function installFromGitHub(source) {
     }
   } finally {
     try {
-      await fs49.rm(tmpDir, { recursive: true, force: true });
+      await fs52.rm(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -25713,14 +26476,14 @@ async function installFromLocal(source) {
   const result = { installed: [], skipped: [], errors: [] };
   const localPath = source.localPath;
   try {
-    await fs49.access(localPath);
+    await fs52.access(localPath);
   } catch {
     result.errors.push(`Local path not found: ${localPath}`);
     return result;
   }
-  const stat = await fs49.stat(localPath);
+  const stat = await fs52.stat(localPath);
   if (stat.isFile()) {
-    const name = path52.basename(path52.dirname(localPath));
+    const name = path55.basename(path55.dirname(localPath));
     try {
       const installed = await installSkillFile(localPath, name, source);
       const lockEntry = {
@@ -25760,14 +26523,14 @@ async function installFromLocal(source) {
 }
 async function remove(name) {
   const installDir = getInstallDir();
-  const subdirPath = path52.join(installDir, name);
+  const subdirPath = path55.join(installDir, name);
   try {
-    await fs49.rm(subdirPath, { recursive: true, force: true });
+    await fs52.rm(subdirPath, { recursive: true, force: true });
   } catch {
   }
-  const flatPath = path52.join(installDir, `${name}.md`);
+  const flatPath = path55.join(installDir, `${name}.md`);
   try {
-    await fs49.rm(flatPath, { force: true });
+    await fs52.rm(flatPath, { force: true });
   } catch {
   }
   return skillLock.removeEntry(name);
@@ -25787,7 +26550,7 @@ async function install(sourceStr) {
       };
   }
 }
-var exec14, skillInstaller;
+var exec15, skillInstaller;
 var init_skill_installer = __esm({
   "core/services/skill-installer.ts"() {
     "use strict";
@@ -25795,7 +26558,7 @@ var init_skill_installer = __esm({
     init_fs();
     init_dependency_validator();
     init_skill_lock();
-    exec14 = promisify15(execCallback7);
+    exec15 = promisify16(execCallback8);
     __name(parseSource, "parseSource");
     __name(discoverSkills, "discoverSkills");
     __name(injectSourceMetadata, "injectSourceMetadata");
@@ -25815,8 +26578,8 @@ var init_skill_installer = __esm({
 });
 
 // core/services/stack-detector.ts
-import fs50 from "node:fs/promises";
-import path53 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"() {
@@ -25975,8 +26738,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path53.join(this.projectPath, "package.json");
-          const content = await fs50.readFile(pkgPath, "utf-8");
+          const pkgPath = path56.join(this.projectPath, "package.json");
+          const content = await fs53.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -25987,7 +26750,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs50.access(path53.join(this.projectPath, filename));
+          await fs53.access(path56.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -25998,16 +26761,16 @@ var init_stack_detector = __esm({
 });
 
 // core/services/sync-verifier.ts
-import { exec as exec15 } from "node:child_process";
-import fs51 from "node:fs/promises";
-import path54 from "node:path";
-import { promisify as promisify16 } from "node:util";
+import { exec as exec16 } from "node:child_process";
+import 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({
   "core/services/sync-verifier.ts"() {
     "use strict";
     init_fs();
-    execAsync10 = promisify16(exec15);
+    execAsync10 = promisify17(exec16);
     BUILTIN_CHECKS = {
       /**
        * Verify all expected context files exist after sync
@@ -26017,9 +26780,9 @@ var init_sync_verifier = __esm({
         const expected = ["context/CLAUDE.md"];
         const missing = [];
         for (const file of expected) {
-          const filePath = path54.join(globalPath, file);
+          const filePath = path57.join(globalPath, file);
           try {
-            await fs51.access(filePath);
+            await fs54.access(filePath);
           } catch {
             missing.push(file);
           }
@@ -26040,9 +26803,9 @@ var init_sync_verifier = __esm({
         const jsonFiles = ["storage/state.json"];
         const invalid = [];
         for (const file of jsonFiles) {
-          const filePath = path54.join(globalPath, file);
+          const filePath = path57.join(globalPath, file);
           try {
-            const content = await fs51.readFile(filePath, "utf-8");
+            const content = await fs54.readFile(filePath, "utf-8");
             JSON.parse(content);
           } catch (error) {
             if (!isNotFoundError(error)) {
@@ -26063,7 +26826,7 @@ var init_sync_verifier = __esm({
        */
       async noSensitiveData(globalPath) {
         const start = Date.now();
-        const contextDir = path54.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,
@@ -26071,10 +26834,10 @@ var init_sync_verifier = __esm({
         ];
         const violations = [];
         try {
-          const files = await fs51.readdir(contextDir);
+          const files = await fs54.readdir(contextDir);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
-            const content = await fs51.readFile(path54.join(contextDir, file), "utf-8");
+            const content = await fs54.readFile(path57.join(contextDir, file), "utf-8");
             for (const pattern of patterns) {
               if (pattern.test(content)) {
                 violations.push(`${file}: potential sensitive data detected`);
@@ -26194,16 +26957,21 @@ var init_sync_verifier = __esm({
 });
 
 // core/services/sync-service.ts
-import { exec as exec16 } from "node:child_process";
-import fs52 from "node:fs/promises";
+import { exec as exec17 } from "node:child_process";
+import fs55 from "node:fs/promises";
 import os16 from "node:os";
-import path55 from "node:path";
-import { promisify as promisify17 } from "node:util";
+import path58 from "node:path";
+import { promisify as promisify18 } from "node:util";
 var execAsync11, SyncService, syncService;
 var init_sync_service = __esm({
   "core/services/sync-service.ts"() {
     "use strict";
     init_ai_tools();
+    init_bm25();
+    init_change_propagator();
+    init_file_hasher();
+    init_git_cochange();
+    init_import_graph();
     init_errors();
     init_command_installer();
     init_config_manager();
@@ -26219,7 +26987,7 @@ var init_sync_service = __esm({
     init_skill_installer();
     init_stack_detector();
     init_sync_verifier();
-    execAsync11 = promisify17(exec16);
+    execAsync11 = promisify18(exec17);
     SyncService = class {
       static {
         __name(this, "SyncService");
@@ -26281,9 +27049,80 @@ var init_sync_service = __esm({
             this.detectCommands(),
             this.detectStack()
           ]);
-          const agents = await this.generateAgents(stack, stats);
+          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)
+              });
+            }
+          }
+          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 = {
@@ -26351,7 +27190,8 @@ var init_sync_service = __esm({
               success: r.success
             })),
             syncMetrics,
-            verification
+            verification,
+            incremental: incrementalInfo
           };
         } catch (error) {
           return {
@@ -26377,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) => fs52.mkdir(path55.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs55.mkdir(path58.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -26448,7 +27288,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path55.basename(this.projectPath),
+          name: path58.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -26465,8 +27305,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path55.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs52.readFile(pkgPath, "utf-8"));
+          const pkgPath = 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";
@@ -26611,12 +27451,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path55.join(this.globalPath, "agents");
+        const agentsPath = path58.join(this.globalPath, "agents");
         try {
-          const files = await fs52.readdir(agentsPath);
+          const files = await fs55.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs52.unlink(path55.join(agentsPath, file));
+              await fs55.unlink(path58.join(agentsPath, file));
             }
           }
         } catch (error) {
@@ -26654,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/.
@@ -26665,7 +27526,7 @@ var init_sync_service = __esm({
         let resolved = content;
         for (const match of matches) {
           const partialName = match[1];
-          const partialPath = path55.join(
+          const partialPath = path58.join(
             __dirname,
             "..",
             "..",
@@ -26674,7 +27535,7 @@ var init_sync_service = __esm({
             `${partialName}.md`
           );
           try {
-            const partialContent = await fs52.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 -->`);
@@ -26685,7 +27546,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path55.join(
+          const templatePath = path58.join(
             __dirname,
             "..",
             "..",
@@ -26694,7 +27555,7 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs52.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", {
@@ -26703,12 +27564,12 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs52.writeFile(path55.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 = path55.join(
+          const templatePath = path58.join(
             __dirname,
             "..",
             "..",
@@ -26717,7 +27578,7 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs52.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");
@@ -26729,7 +27590,7 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs52.writeFile(path55.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs55.writeFile(path58.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -26797,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]))
         };
-        fs52.writeFile(
-          path55.join(this.globalPath, "config", "skills.json"),
+        fs55.writeFile(
+          path58.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch((error) => {
@@ -26816,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 = path55.join(
+          const mappingsPath = path58.join(
             __dirname,
             "..",
             "..",
@@ -26824,7 +27685,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
             "config",
             "skill-mappings.json"
           );
-          const mappingsContent = await fs52.readFile(mappingsPath, "utf-8");
+          const mappingsContent = await fs55.readFile(mappingsPath, "utf-8");
           const mappings = JSON.parse(mappingsContent);
           const agentToSkillMap = mappings.agentToSkillMap || {};
           const packagesToInstall = [];
@@ -26837,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 = path55.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 = path55.join(skillsDir, skillName, "SKILL.md");
-            const flatPath = path55.join(skillsDir, `${skillName}.md`);
+            const subdirPath = path58.join(skillsDir, skillName, "SKILL.md");
+            const flatPath = path58.join(skillsDir, `${skillName}.md`);
             let alreadyInstalled = false;
             try {
-              await fs52.access(subdirPath);
+              await fs55.access(subdirPath);
               alreadyInstalled = true;
             } catch {
               try {
-                await fs52.access(flatPath);
+                await fs55.access(flatPath);
                 alreadyInstalled = true;
               } catch {
               }
@@ -26900,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 = path55.join(this.globalPath, "project.json");
+        const projectJsonPath = path58.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs52.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs55.readFile(projectJsonPath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing project.json", {
             path: projectJsonPath,
@@ -26929,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 fs52.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 = path55.join(this.globalPath, "storage", "state.json");
+        const statePath = path58.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs52.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) });
         }
@@ -26966,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 fs52.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,
@@ -26980,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 = path55.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path58.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: getTimestamp(),
           action: "sync",
@@ -26989,7 +27850,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs52.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs55.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -27009,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 = path55.join(this.globalPath, file);
-            const content = await fs52.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) });
@@ -27018,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 = path55.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs52.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", {
@@ -27081,7 +27942,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs52.access(path55.join(this.projectPath, filename));
+          await fs55.access(path58.join(this.projectPath, filename));
           return true;
         } catch (error) {
           logger_default.debug("File not found", { filename, error: getErrorMessage(error) });
@@ -27090,8 +27951,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path55.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs52.readFile(pkgPath, "utf-8"));
+          const pkgPath = 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) });
@@ -27252,22 +28113,22 @@ __export(uninstall_exports, {
   uninstall: () => uninstall
 });
 import { execSync as execSync3 } from "node:child_process";
-import fs53 from "node:fs/promises";
+import fs56 from "node:fs/promises";
 import os17 from "node:os";
-import path56 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 fs53.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs56.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path56.join(dirPath, entry.name);
+      const entryPath = path59.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs53.stat(entryPath);
+          const stats = await fs56.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -27286,7 +28147,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs53.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs56.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -27319,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(path56.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,
@@ -27329,12 +28190,12 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path56.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 fs53.readFile(claudeMdPath, "utf-8");
+      const content = await fs56.readFile(claudeMdPath, "utf-8");
       hasPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -27363,7 +28224,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path56.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,
@@ -27379,12 +28240,12 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path56.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 fs53.readFile(geminiMdPath, "utf-8");
+      const content = await fs56.readFile(geminiMdPath, "utf-8");
       hasGeminiPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -27401,7 +28262,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs53.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;
     }
@@ -27410,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 fs53.unlink(filePath);
+      await fs56.unlink(filePath);
     } else {
-      await fs53.writeFile(filePath, `${newContent}
+      await fs56.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -27423,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 = path56.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path59.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs53.mkdir(backupDir, { recursive: true });
+    await fs56.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (await fileExists(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path56.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path59.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -27436,15 +28297,15 @@ async function createBackup3() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs53.mkdir(dest, { recursive: true });
-  const entries = await fs53.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 = path56.join(src, entry.name);
-    const destPath = path56.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 fs53.copyFile(srcPath, destPath);
+      await fs56.copyFile(srcPath, destPath);
     }
   }
 }
@@ -27460,10 +28321,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs53.rm(item.path, { recursive: true, force: true });
+        await fs56.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs53.unlink(item.path);
+        await fs56.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -27640,7 +28501,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path57 from "node:path";
+import path60 from "node:path";
 import chalk13 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -27829,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) {
@@ -27861,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: ${path57.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("");
@@ -28034,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"
@@ -28592,9 +29455,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync4 } from "node:child_process";
-import fs54 from "node:fs/promises";
+import fs57 from "node:fs/promises";
 import os18 from "node:os";
-import path58 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";
@@ -28733,12 +29596,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path58.join(os18.homedir(), ".gemini", "commands");
-    const routerSource = path58.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
-    const routerDest = path58.join(geminiCommandsDir, "p.toml");
-    await fs54.mkdir(geminiCommandsDir, { recursive: true });
+    const geminiCommandsDir = 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 fs54.copyFile(routerSource, routerDest);
+      await fs57.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -28749,15 +29612,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path58.join(os18.homedir(), ".gemini");
-    const globalConfigPath = path58.join(geminiDir, "GEMINI.md");
-    const templatePath = path58.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
-    await fs54.mkdir(geminiDir, { recursive: true });
-    const templateContent = await fs54.readFile(templatePath, "utf-8");
+    const geminiDir = 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 fs54.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs57.readFile(globalConfigPath, "utf-8");
       configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -28767,7 +29630,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!configExists) {
-      await fs54.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 -->";
@@ -28777,7 +29640,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      await fs54.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));
@@ -28789,7 +29652,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    await fs54.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)}`);
@@ -28798,18 +29661,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path58.join(os18.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = path58.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = path58.join(prjctSkillDir, "SKILL.md");
-    const templatePath = path58.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
-    await fs54.mkdir(prjctSkillDir, { recursive: true });
+    const antigravitySkillsDir = 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 fs54.readFile(templatePath, "utf-8");
-    await fs54.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)}`);
@@ -28828,24 +29691,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = path58.join(projectRoot, ".cursor");
-    const rulesDir = path58.join(cursorDir, "rules");
-    const commandsDir = path58.join(cursorDir, "commands");
-    const routerMdcDest = path58.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = path58.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = path58.join(PACKAGE_ROOT, "templates", "cursor", "commands");
-    await fs54.mkdir(rulesDir, { recursive: true });
-    await fs54.mkdir(commandsDir, { recursive: true });
+    const cursorDir = 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 fs54.copyFile(routerMdcSource, routerMdcDest);
+      await fs57.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
     if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await fs54.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 = path58.join(cursorCommandsSource, file);
-        const dest = path58.join(commandsDir, file);
-        await fs54.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;
     }
@@ -28859,7 +29722,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path58.join(projectRoot, ".gitignore");
+    const gitignorePath = path61.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -28874,7 +29737,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs54.readFile(gitignorePath, "utf-8");
+      content = await fs57.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -28889,7 +29752,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs54.writeFile(gitignorePath, newContent, "utf-8");
+    await fs57.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -28897,11 +29760,11 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasCursorProject(projectRoot) {
-  return await fileExists(path58.join(projectRoot, ".cursor"));
+  return await fileExists(path61.join(projectRoot, ".cursor"));
 }
 async function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path58.join(projectRoot, ".cursor");
-  const routerPath = path58.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) {
@@ -28912,26 +29775,26 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = path58.join(projectRoot, ".windsurf");
-    const rulesDir = path58.join(windsurfDir, "rules");
-    const workflowsDir = path58.join(windsurfDir, "workflows");
-    const routerDest = path58.join(rulesDir, "prjct.md");
-    const routerSource = path58.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = path58.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
-    await fs54.mkdir(rulesDir, { recursive: true });
-    await fs54.mkdir(workflowsDir, { recursive: true });
+    const windsurfDir = 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 fs54.copyFile(routerSource, routerDest);
+      await fs57.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
     if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await fs54.readdir(windsurfWorkflowsSource)).filter(
+      const workflowFiles = (await fs57.readdir(windsurfWorkflowsSource)).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of workflowFiles) {
-        const src = path58.join(windsurfWorkflowsSource, file);
-        const dest = path58.join(workflowsDir, file);
-        await fs54.copyFile(src, dest);
+        const src = path61.join(windsurfWorkflowsSource, file);
+        const dest = path61.join(workflowsDir, file);
+        await fs57.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -28945,7 +29808,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path58.join(projectRoot, ".gitignore");
+    const gitignorePath = path61.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -28960,7 +29823,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs54.readFile(gitignorePath, "utf-8");
+      content = await fs57.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -28975,7 +29838,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs54.writeFile(gitignorePath, newContent, "utf-8");
+    await fs57.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -28983,32 +29846,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 async function hasWindsurfProject(projectRoot) {
-  return await fileExists(path58.join(projectRoot, ".windsurf"));
+  return await fileExists(path61.join(projectRoot, ".windsurf"));
 }
 async function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path58.join(projectRoot, ".windsurf");
-  const routerPath = path58.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 = path58.join(os18.homedir(), ".prjct-cli", "projects");
+    const projectsDir = path61.join(os18.homedir(), ".prjct-cli", "projects");
     if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = (await fs54.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await fs57.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path58.join(projectsDir, projectId, "project.json");
+      const projectJsonPath = path61.join(projectsDir, projectId, "project.json");
       if (!await fileExists(projectJsonPath)) {
         continue;
       }
       try {
-        const content = await fs54.readFile(projectJsonPath, "utf8");
+        const content = await fs57.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          await fs54.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await fs57.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -29030,7 +29893,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
   if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(await fs54.readFile(settingsPath, "utf8"));
+      settings = JSON.parse(await fs57.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -29038,42 +29901,42 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  await fs54.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await fs57.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path58.join(os18.homedir(), ".claude");
-    const settingsPath = path58.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = path58.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path58.join(os18.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = path58.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = path58.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = path58.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = path58.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = path58.join(prjctStatusLineDir, "config.json");
-    const assetsDir = path58.join(PACKAGE_ROOT, "assets", "statusline");
-    const sourceScript = path58.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = path58.join(assetsDir, "themes");
-    const sourceLibDir = path58.join(assetsDir, "lib");
-    const sourceComponentsDir = path58.join(assetsDir, "components");
-    const sourceConfigPath = path58.join(assetsDir, "default-config.json");
+    const claudeDir = 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 fs54.mkdir(claudeDir, { recursive: true });
+      await fs57.mkdir(claudeDir, { recursive: true });
     }
     if (!await fileExists(prjctStatusLineDir)) {
-      await fs54.mkdir(prjctStatusLineDir, { recursive: true });
+      await fs57.mkdir(prjctStatusLineDir, { recursive: true });
     }
     if (!await fileExists(prjctThemesDir)) {
-      await fs54.mkdir(prjctThemesDir, { recursive: true });
+      await fs57.mkdir(prjctThemesDir, { recursive: true });
     }
     if (!await fileExists(prjctLibDir)) {
-      await fs54.mkdir(prjctLibDir, { recursive: true });
+      await fs57.mkdir(prjctLibDir, { recursive: true });
     }
     if (!await fileExists(prjctComponentsDir)) {
-      await fs54.mkdir(prjctComponentsDir, { recursive: true });
+      await fs57.mkdir(prjctComponentsDir, { recursive: true });
     }
     if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await fs54.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) {
@@ -29081,7 +29944,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          await fs54.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await fs57.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         await installStatusLineModules(sourceLibDir, prjctLibDir);
         await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -29091,21 +29954,21 @@ async function installStatusLine() {
       }
     }
     if (await fileExists(sourceScript)) {
-      let scriptContent = await fs54.readFile(sourceScript, "utf8");
+      let scriptContent = await fs57.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await fs54.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 fs54.readdir(sourceThemeDir);
+        const themes = await fs57.readdir(sourceThemeDir);
         for (const theme of themes) {
-          const src = path58.join(sourceThemeDir, theme);
-          const dest = path58.join(prjctThemesDir, theme);
-          await fs54.copyFile(src, dest);
+          const src = path61.join(sourceThemeDir, theme);
+          const dest = path61.join(prjctThemesDir, theme);
+          await fs57.copyFile(src, dest);
         }
       }
       if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await fs54.copyFile(sourceConfigPath, prjctConfigPath);
+        await fs57.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -29140,7 +30003,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      await fs54.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs57.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -29152,10 +30015,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path58.join(os18.homedir(), ".claude");
-    const mcpConfigPath = path58.join(claudeDir, "mcp.json");
+    const claudeDir = path61.join(os18.homedir(), ".claude");
+    const mcpConfigPath = path61.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
-      await fs54.mkdir(claudeDir, { recursive: true });
+      await fs57.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -29166,16 +30029,16 @@ async function installContext7MCP() {
       }
     };
     if (await fileExists(mcpConfigPath)) {
-      const existingContent = await fs54.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 fs54.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await fs57.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      await fs54.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)}`);
@@ -29185,34 +30048,34 @@ async function installStatusLineModules(sourceDir, destDir) {
   if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = await fs54.readdir(sourceDir);
+  const files = await fs57.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path58.join(sourceDir, file);
-      const dest = path58.join(destDir, file);
-      await fs54.copyFile(src, dest);
-      await fs54.chmod(dest, 493);
+      const src = 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 fs54.lstat(linkPath);
+      const stats = await fs57.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = await fs54.readlink(linkPath);
+        const existingTarget = await fs57.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      await fs54.unlink(linkPath);
+      await fs57.unlink(linkPath);
     }
-    await fs54.symlink(targetPath, linkPath);
+    await fs57.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
       if (await fileExists(targetPath)) {
-        await fs54.copyFile(targetPath, linkPath);
-        await fs54.chmod(linkPath, 493);
+        await fs57.copyFile(targetPath, linkPath);
+        await fs57.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -29627,7 +30490,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path59 from "node:path";
+import path62 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -29654,7 +30517,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path59.basename(projectPath);
+          const projectName = path62.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -29906,8 +30769,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs55 from "node:fs/promises";
-import path60 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"() {
@@ -30033,8 +30896,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path60.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs55.readFile(analysisPath, "utf-8");
+          const analysisPath = 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",
@@ -30053,7 +30916,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path61 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 };
@@ -30069,7 +30932,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_exports.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path61.basename(filePath));
+          results.rotated.push(path64.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -30176,7 +31039,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path62 from "node:path";
+import path65 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -30188,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 = path62.join(
+    const designsPath = path65.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -30228,7 +31091,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path62.join(designsPath, designFileName);
+    const designFilePath = path65.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -30253,7 +31116,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path63 from "node:path";
+import path66 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -30305,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 = path63.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 {
@@ -30323,7 +31186,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path63.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);
@@ -30363,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 = path63.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path63.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);
@@ -30423,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 = path63.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path63.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);
@@ -30627,8 +31490,8 @@ ${chalk16.cyan("Performance Report")} ${chalk16.dim(`(last ${days} days)`)}`);
 });
 
 // core/commands/setup.ts
-import fs56 from "node:fs/promises";
-import path64 from "node:path";
+import fs59 from "node:fs/promises";
+import path67 from "node:path";
 import chalk17 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -30757,7 +31620,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path64.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path67.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -30815,11 +31678,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          await fs56.writeFile(statusLinePath, scriptContent, { mode: 493 });
+          await fs59.writeFile(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
           if (await fileExists(settingsPath)) {
             try {
-              settings = JSON.parse(await fs56.readFile(settingsPath, "utf8"));
+              settings = JSON.parse(await fs59.readFile(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -30827,7 +31690,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          await fs56.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) };
@@ -30883,18 +31746,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path65 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(path65.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists2(path65.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists2(path65.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists2(path65.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists2(path65.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists2(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) {
@@ -30910,7 +31773,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path65.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);
@@ -30927,27 +31790,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists2(path65.join(projectPath, "pytest.ini"))) {
+  if (await fileExists2(path68.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path65.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path68.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists2(path65.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists2(path68.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists2(path65.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(path65.join(projectPath, "pom.xml"))) {
+  if (await fileExists2(path68.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists2(path65.join(projectPath, "gradlew")) && (await fileExists2(path65.join(projectPath, "build.gradle")) || await fileExists2(path65.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists2(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" };
@@ -30964,8 +31827,8 @@ var init_project_commands = __esm({
 });
 
 // core/workflow/workflow-preferences.ts
-import { exec as exec17 } from "node:child_process";
-import { promisify as promisify18 } from "node:util";
+import { exec as exec18 } from "node:child_process";
+import { promisify as promisify19 } from "node:util";
 import chalk18 from "chalk";
 function prefKey(hook, command) {
   return `workflow:${hook}_${command}`;
@@ -31108,7 +31971,7 @@ var init_workflow_preferences = __esm({
     init_memory_system();
     init_constants();
     init_fs();
-    execAsync12 = promisify18(exec17);
+    execAsync12 = promisify19(exec18);
     sessionPreferences = /* @__PURE__ */ new Map();
     oncePreferences = /* @__PURE__ */ new Map();
     __name(prefKey, "prefKey");
@@ -31122,7 +31985,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path66 from "node:path";
+import path69 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -31268,7 +32131,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path66.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);
@@ -31290,7 +32153,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path66.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())}
 
@@ -31538,8 +32401,8 @@ var init_cache2 = __esm({
 });
 
 // core/utils/keychain.ts
-import { exec as exec18 } from "node:child_process";
-import { promisify as promisify19 } from "node:util";
+import { exec as exec19 } from "node:child_process";
+import { promisify as promisify20 } from "node:util";
 async function getCredential(key) {
   if (process.platform !== "darwin") {
     return getEnvFallback(key);
@@ -31566,7 +32429,7 @@ var init_keychain = __esm({
   "core/utils/keychain.ts"() {
     "use strict";
     init_fs();
-    execAsync13 = promisify19(exec18);
+    execAsync13 = promisify20(exec19);
     SERVICE_NAME = "prjct-cli";
     __name(getCredential, "getCredential");
     __name(getEnvFallback, "getEnvFallback");
@@ -32334,11 +33197,11 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs57 from "node:fs/promises";
+import fs60 from "node:fs/promises";
 import os19 from "node:os";
-import path67 from "node:path";
+import path70 from "node:path";
 function getCredentialsPath(projectId) {
-  return path67.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);
@@ -32346,7 +33209,7 @@ async function getProjectCredentials(projectId) {
     return {};
   }
   try {
-    return JSON.parse(await fs57.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 {};
@@ -33018,7 +33881,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.16.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: {
@@ -33125,7 +33988,7 @@ var require_package = __commonJS({
 // core/index.ts
 var core_exports = {};
 import os20 from "node:os";
-import path68 from "node:path";
+import path71 from "node:path";
 import chalk20 from "chalk";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
@@ -33230,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"),
@@ -33338,13 +34202,13 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 async function displayVersion(version) {
   const detection = await detectAllProviders();
-  const claudeCommandPath = path68.join(os20.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path68.join(os20.homedir(), ".gemini", "commands", "p.toml");
+  const claudeCommandPath = 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(path68.join(process.cwd(), ".cursor", "commands", "sync.md")),
-    fileExists(path68.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(`
@@ -33483,7 +34347,7 @@ init_ai_provider();
 init_config_manager();
 init_editors_config();
 import os21 from "node:os";
-import path69 from "node:path";
+import path72 from "node:path";
 import chalk21 from "chalk";
 
 // core/server/server.ts
@@ -34304,13 +35168,13 @@ async function checkRoutersInstalled() {
   const home = os21.homedir();
   const detection = await detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path69.join(home, ".claude", "commands", "p.md");
+    const claudeRouter = path72.join(home, ".claude", "commands", "p.md");
     if (!await fileExists(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path69.join(home, ".gemini", "commands", "p.toml");
+    const geminiRouter = path72.join(home, ".gemini", "commands", "p.toml");
     if (!await fileExists(geminiRouter)) {
       return false;
     }
@@ -34451,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 = path69.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",
@@ -34478,12 +35342,12 @@ if (args[0] === "start" || args[0] === "setup") {
     windsurfDetected,
     windsurfConfigured
   ] = await Promise.all([
-    fileExists(path69.join(home, ".claude", "commands", "p.md")),
-    fileExists(path69.join(home, ".gemini", "commands", "p.toml")),
-    fileExists(path69.join(cwd, ".cursor")),
-    fileExists(path69.join(cwd, ".cursor", "rules", "prjct.mdc")),
-    fileExists(path69.join(cwd, ".windsurf")),
-    fileExists(path69.join(cwd, ".windsurf", "rules", "prjct.md"))
+    fileExists(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}
@@ -34522,7 +35386,7 @@ ${chalk21.dim("Run 'prjct init' to configure (Cursor/Windsurf IDE)")}
 ${chalk21.cyan("https://prjct.app")}
 `);
 } else {
-  const configPath = path69.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path72.join(os21.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = await checkRoutersInstalled();
   if (!await fileExists(configPath) || !routersInstalled) {
     console.log(`