prjct-cli 0.56.1 → 0.58.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) => (path56) => {
-  var fn = map[path56];
+var __glob = (map) => (path57) => {
+  var fn = map[path57];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path56);
+  throw new Error("Module not found in bundle: " + path57);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -1178,6 +1178,7 @@ import crypto2 from "node:crypto";
 import fs4 from "node:fs/promises";
 import os2 from "node:os";
 import path4 from "node:path";
+import { globSync } from "glob";
 var PathManager, pathManager, path_manager_default;
 var init_path_manager = __esm({
   "core/infrastructure/path-manager.ts"() {
@@ -1470,6 +1471,158 @@ var init_path_manager = __esm({
       getContextPath(projectId) {
         return path4.join(this.getGlobalProjectPath(projectId), "context");
       }
+      // ===========================================================================
+      // Monorepo Detection
+      // ===========================================================================
+      /**
+       * Detect if a project is a monorepo and get package information
+       */
+      async detectMonorepo(projectPath) {
+        const result = {
+          isMonorepo: false,
+          type: null,
+          rootPath: projectPath,
+          packages: []
+        };
+        const checks = [
+          { file: "pnpm-workspace.yaml", type: "pnpm" },
+          { file: "lerna.json", type: "lerna" },
+          { file: "nx.json", type: "nx" },
+          { file: "rush.json", type: "rush" },
+          { file: "turbo.json", type: "turborepo" }
+        ];
+        for (const check of checks) {
+          const filePath = path4.join(projectPath, check.file);
+          if (await fileExists(filePath)) {
+            result.isMonorepo = true;
+            result.type = check.type;
+            break;
+          }
+        }
+        if (!result.isMonorepo) {
+          const packageJsonPath = path4.join(projectPath, "package.json");
+          if (await fileExists(packageJsonPath)) {
+            try {
+              const content = await fs4.readFile(packageJsonPath, "utf-8");
+              const pkg = JSON.parse(content);
+              if (pkg.workspaces) {
+                result.isMonorepo = true;
+                result.type = "npm";
+              }
+            } catch {
+            }
+          }
+        }
+        if (result.isMonorepo) {
+          result.packages = await this.discoverMonorepoPackages(projectPath, result.type);
+        }
+        return result;
+      }
+      /**
+       * Discover all packages in a monorepo
+       */
+      async discoverMonorepoPackages(rootPath, type) {
+        const packages = [];
+        let patterns = [];
+        try {
+          if (type === "pnpm") {
+            const yaml = await fs4.readFile(path4.join(rootPath, "pnpm-workspace.yaml"), "utf-8");
+            const match = yaml.match(/packages:\s*\n((?:\s*-\s*.+\n?)+)/);
+            if (match) {
+              patterns = match[1].split("\n").map((line) => line.replace(/^\s*-\s*['"]?|['"]?\s*$/g, "")).filter(Boolean);
+            }
+          } else if (type === "npm" || type === "lerna") {
+            const packageJsonPath = path4.join(rootPath, "package.json");
+            const content = await fs4.readFile(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (Array.isArray(pkg.workspaces)) {
+              patterns = pkg.workspaces;
+            } else if (pkg.workspaces?.packages) {
+              patterns = pkg.workspaces.packages;
+            }
+            if (type === "lerna") {
+              const lernaPath = path4.join(rootPath, "lerna.json");
+              if (await fileExists(lernaPath)) {
+                const lernaContent = await fs4.readFile(lernaPath, "utf-8");
+                const lerna = JSON.parse(lernaContent);
+                if (lerna.packages) {
+                  patterns = lerna.packages;
+                }
+              }
+            }
+          } else if (type === "nx") {
+            patterns = ["apps/*", "libs/*", "packages/*"];
+          } else if (type === "turborepo") {
+            const packageJsonPath = path4.join(rootPath, "package.json");
+            const content = await fs4.readFile(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (Array.isArray(pkg.workspaces)) {
+              patterns = pkg.workspaces;
+            }
+          }
+          if (patterns.length === 0) {
+            patterns = ["packages/*", "apps/*", "libs/*"];
+          }
+          for (const pattern of patterns) {
+            if (pattern.startsWith("!")) continue;
+            const matches = globSync(pattern, {
+              cwd: rootPath,
+              absolute: false
+            });
+            for (const match of matches) {
+              const packagePath = path4.join(rootPath, match);
+              const packageJsonPath = path4.join(packagePath, "package.json");
+              if (await fileExists(packageJsonPath)) {
+                try {
+                  const content = await fs4.readFile(packageJsonPath, "utf-8");
+                  const pkg = JSON.parse(content);
+                  const prjctMdPath = path4.join(packagePath, "PRJCT.md");
+                  packages.push({
+                    name: pkg.name || path4.basename(match),
+                    path: packagePath,
+                    relativePath: match,
+                    hasPrjctMd: await fileExists(prjctMdPath)
+                  });
+                } catch {
+                }
+              }
+            }
+          }
+        } catch {
+        }
+        return packages;
+      }
+      /**
+       * Check if current path is within a monorepo package
+       * Returns the package info if found, null otherwise
+       */
+      async findContainingPackage(currentPath, monoInfo) {
+        if (!monoInfo.isMonorepo) return null;
+        const normalizedCurrent = path4.resolve(currentPath);
+        for (const pkg of monoInfo.packages) {
+          const normalizedPkg = path4.resolve(pkg.path);
+          if (normalizedCurrent.startsWith(normalizedPkg)) {
+            return pkg;
+          }
+        }
+        return null;
+      }
+      /**
+       * Find monorepo root from any subdirectory
+       * Walks up the directory tree looking for monorepo markers
+       */
+      async findMonorepoRoot(startPath) {
+        let currentPath = path4.resolve(startPath);
+        const root = path4.parse(currentPath).root;
+        while (currentPath !== root) {
+          const monoInfo = await this.detectMonorepo(currentPath);
+          if (monoInfo.isMonorepo) {
+            return currentPath;
+          }
+          currentPath = path4.dirname(currentPath);
+        }
+        return null;
+      }
     };
     pathManager = new PathManager();
     path_manager_default = pathManager;
@@ -3866,8 +4019,8 @@ function tryResolve(basePath, projectPath) {
   for (const ext of extensions) {
     const fullPath = basePath + ext;
     try {
-      const fs47 = __require("node:fs");
-      if (fs47.existsSync(fullPath) && fs47.statSync(fullPath).isFile()) {
+      const fs48 = __require("node:fs");
+      if (fs48.existsSync(fullPath) && fs48.statSync(fullPath).isFile()) {
         return path12.relative(projectPath, fullPath);
       }
     } catch {
@@ -5050,11 +5203,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs47 = await import("node:fs/promises");
-  const path56 = await import("node:path");
-  const fullPath = path56.isAbsolute(filePath) ? filePath : path56.join(projectPath, filePath);
+  const fs48 = await import("node:fs/promises");
+  const path57 = await import("node:path");
+  const fullPath = path57.isAbsolute(filePath) ? filePath : path57.join(projectPath, filePath);
   try {
-    const stat = await fs47.stat(fullPath);
+    const stat = await fs48.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5121,11 +5274,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs47 = await import("node:fs/promises");
-  const path56 = await import("node:path");
-  const fullPath = path56.isAbsolute(targetPath) ? targetPath : path56.join(projectPath, targetPath);
+  const fs48 = await import("node:fs/promises");
+  const path57 = await import("node:path");
+  const fullPath = path57.isAbsolute(targetPath) ? targetPath : path57.join(projectPath, targetPath);
   try {
-    const stat = await fs47.stat(fullPath);
+    const stat = await fs48.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -15556,6 +15709,254 @@ var init_memory_service = __esm({
   }
 });
 
+// core/services/nested-context-resolver.ts
+import fs32 from "node:fs/promises";
+import path33 from "node:path";
+var NestedContextResolver;
+var init_nested_context_resolver = __esm({
+  "core/services/nested-context-resolver.ts"() {
+    "use strict";
+    init_path_manager();
+    init_file_helper();
+    NestedContextResolver = class {
+      static {
+        __name(this, "NestedContextResolver");
+      }
+      rootPath;
+      monoInfo = null;
+      constructor(rootPath) {
+        this.rootPath = path33.resolve(rootPath);
+      }
+      /**
+       * Initialize the resolver with monorepo detection
+       */
+      async initialize() {
+        this.monoInfo = await path_manager_default.detectMonorepo(this.rootPath);
+      }
+      /**
+       * Discover all PRJCT.md files in the project/monorepo
+       */
+      async discoverContextFiles() {
+        const contexts = [];
+        const rootPrjctPath = path33.join(this.rootPath, "PRJCT.md");
+        if (await fileExists(rootPrjctPath)) {
+          const rootContext = await this.loadContext(rootPrjctPath, null);
+          contexts.push(rootContext);
+        }
+        if (this.monoInfo?.isMonorepo) {
+          for (const pkg of this.monoInfo.packages) {
+            const pkgPrjctPath = path33.join(pkg.path, "PRJCT.md");
+            if (await fileExists(pkgPrjctPath)) {
+              const parentContext = contexts.find((c) => c.depth === 0) || null;
+              const pkgContext = await this.loadContext(pkgPrjctPath, parentContext, pkg);
+              contexts.push(pkgContext);
+              if (parentContext) {
+                parentContext.children.push(pkgContext);
+              }
+            }
+          }
+        }
+        const additionalContexts = await this.scanForNestedContexts(this.rootPath, contexts);
+        contexts.push(...additionalContexts);
+        return contexts;
+      }
+      /**
+       * Load a single PRJCT.md file into a NestedContext
+       */
+      async loadContext(filePath, parent, pkg = null) {
+        const content = await fs32.readFile(filePath, "utf-8");
+        const relativePath = path33.relative(this.rootPath, filePath);
+        const depth = relativePath.split(path33.sep).length - 1;
+        return {
+          path: filePath,
+          relativePath,
+          depth,
+          parent,
+          children: [],
+          content,
+          sections: this.parseSections(content),
+          package: pkg
+        };
+      }
+      /**
+       * Parse PRJCT.md content into sections
+       */
+      parseSections(content) {
+        const sections = [];
+        const lines = content.split("\n");
+        let currentSection = null;
+        let currentContent = [];
+        for (const line of lines) {
+          const headerMatch = line.match(/^##\s+(.+)$/);
+          if (headerMatch) {
+            if (currentSection) {
+              currentSection.content = currentContent.join("\n").trim();
+              sections.push(currentSection);
+            }
+            const sectionName = headerMatch[1];
+            const override = sectionName.includes("@override") || sectionName.includes("(override)");
+            currentSection = {
+              name: sectionName.replace(/@override|\(override\)/gi, "").trim(),
+              content: "",
+              override
+            };
+            currentContent = [];
+          } else if (currentSection) {
+            currentContent.push(line);
+          }
+        }
+        if (currentSection) {
+          currentSection.content = currentContent.join("\n").trim();
+          sections.push(currentSection);
+        }
+        return sections;
+      }
+      /**
+       * Scan for additional nested PRJCT.md files not in packages
+       */
+      async scanForNestedContexts(dir, existing) {
+        const found = [];
+        const existingPaths = new Set(existing.map((c) => c.path));
+        const scan = /* @__PURE__ */ __name(async (currentDir, depth) => {
+          if (depth > 5) return;
+          try {
+            const entries = await fs32.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
+                continue;
+              }
+              if (entry.isDirectory()) {
+                const subDir = path33.join(currentDir, entry.name);
+                const prjctPath = path33.join(subDir, "PRJCT.md");
+                if (await fileExists(prjctPath) && !existingPaths.has(prjctPath)) {
+                  const parent = this.findParentContext(prjctPath, existing.concat(found));
+                  const context2 = await this.loadContext(prjctPath, parent);
+                  found.push(context2);
+                  existingPaths.add(prjctPath);
+                  if (parent) {
+                    parent.children.push(context2);
+                  }
+                }
+                await scan(subDir, depth + 1);
+              }
+            }
+          } catch {
+          }
+        }, "scan");
+        await scan(dir, 0);
+        return found;
+      }
+      /**
+       * Find the parent context for a given path
+       */
+      findParentContext(filePath, contexts) {
+        const fileDir = path33.dirname(filePath);
+        const sorted = [...contexts].sort((a, b) => b.depth - a.depth);
+        for (const ctx of sorted) {
+          const ctxDir = path33.dirname(ctx.path);
+          if (fileDir.startsWith(ctxDir) && fileDir !== ctxDir) {
+            return ctx;
+          }
+        }
+        return null;
+      }
+      /**
+       * Resolve context for a specific path by merging parent contexts
+       * Deeper files take precedence (can override parent sections)
+       */
+      async resolveContextForPath(targetPath) {
+        const contexts = await this.discoverContextFiles();
+        const targetDir = path33.resolve(targetPath);
+        let bestMatch = null;
+        for (const ctx of contexts) {
+          const ctxDir = path33.dirname(ctx.path);
+          if (targetDir.startsWith(ctxDir)) {
+            if (!bestMatch || ctx.depth > bestMatch.depth) {
+              bestMatch = ctx;
+            }
+          }
+        }
+        if (!bestMatch) {
+          return {
+            content: "",
+            sources: [],
+            overrides: []
+          };
+        }
+        const chain = [];
+        let current = bestMatch;
+        while (current) {
+          chain.unshift(current);
+          current = current.parent;
+        }
+        return this.mergeContextChain(chain);
+      }
+      /**
+       * Merge a chain of contexts following inheritance rules
+       */
+      mergeContextChain(chain) {
+        const mergedSections = /* @__PURE__ */ new Map();
+        const sources = [];
+        const overrides = [];
+        for (const ctx of chain) {
+          sources.push(ctx.relativePath);
+          for (const section of ctx.sections) {
+            if (section.override || !mergedSections.has(section.name)) {
+              mergedSections.set(section.name, section.content);
+              if (section.override) {
+                overrides.push(`${ctx.relativePath}:${section.name}`);
+              }
+            } else {
+              const existing = mergedSections.get(section.name) || "";
+              mergedSections.set(section.name, `${existing}
+
+${section.content}`);
+            }
+          }
+        }
+        const parts = [];
+        for (const [name, content] of mergedSections) {
+          parts.push(`## ${name}
+
+${content}`);
+        }
+        return {
+          content: parts.join("\n\n---\n\n"),
+          sources,
+          overrides
+        };
+      }
+      /**
+       * Get context for a specific monorepo package
+       */
+      async getPackageContext(packageName) {
+        if (!this.monoInfo?.isMonorepo) {
+          return null;
+        }
+        const pkg = this.monoInfo.packages.find((p) => p.name === packageName);
+        if (!pkg) {
+          return null;
+        }
+        return this.resolveContextForPath(pkg.path);
+      }
+      /**
+       * Get all package contexts in the monorepo
+       */
+      async getAllPackageContexts() {
+        const results = /* @__PURE__ */ new Map();
+        if (!this.monoInfo?.isMonorepo) {
+          return results;
+        }
+        for (const pkg of this.monoInfo.packages) {
+          const ctx = await this.resolveContextForPath(pkg.path);
+          results.set(pkg.name, ctx);
+        }
+        return results;
+      }
+    };
+  }
+});
+
 // core/services/project-index.ts
 import { exec as exec7 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
@@ -16039,16 +16440,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs47 = await import("node:fs/promises");
-        const path56 = await import("node:path");
+        const fs48 = await import("node:fs/promises");
+        const path57 = await import("node:path");
         try {
-          const files = await fs47.readdir(this.projectPath);
+          const files = await fs48.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 = path56.join(this.projectPath, "package.json");
-            const pkgContent = await fs47.readFile(pkgPath, "utf-8");
+            const pkgPath = path57.join(this.projectPath, "package.json");
+            const pkgContent = await fs48.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -16084,32 +16485,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs47 = await import("node:fs/promises");
-        const path56 = await import("node:path");
+        const fs48 = await import("node:fs/promises");
+        const path57 = await import("node:path");
         const os17 = await import("node:os");
         const agents = [];
         try {
-          await fs47.access(path56.join(os17.homedir(), ".claude"));
+          await fs48.access(path57.join(os17.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs47.access(path56.join(this.projectPath, ".cursorrules"));
+          await fs48.access(path57.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs47.access(path56.join(this.projectPath, ".windsurfrules"));
+          await fs48.access(path57.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs47.access(path56.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs48.access(path57.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs47.access(path56.join(os17.homedir(), ".gemini"));
+          await fs48.access(path57.join(os17.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -16119,17 +16520,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs47 = await import("node:fs/promises");
-        const path56 = await import("node:path");
+        const fs48 = await import("node:fs/promises");
+        const path57 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs47.readdir(this.projectPath);
+          const files = await fs48.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path56.join(this.projectPath, "package.json");
-            const pkgContent = await fs47.readFile(pkgPath, "utf-8");
+            const pkgPath = path57.join(this.projectPath, "package.json");
+            const pkgContent = await fs48.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -16236,14 +16637,14 @@ var init_wizard = __esm({
 
 // core/context/generator.ts
 import { exec as exec8 } from "node:child_process";
-import fs32 from "node:fs/promises";
-import path33 from "node:path";
+import fs33 from "node:fs/promises";
+import path34 from "node:path";
 import { promisify as promisify8 } from "node:util";
 async function generateContext(projectId, repoPath) {
   const _globalPath = path_manager_default.getGlobalProjectPath(projectId);
   const contextPath = path_manager_default.getContextPath(projectId);
   const storage = getStorage(projectId);
-  await fs32.mkdir(contextPath, { recursive: true });
+  await fs33.mkdir(contextPath, { recursive: true });
   const project = await storage.read(["project"]) || {};
   const taskPaths = await storage.list(["task"]);
   const featurePaths = await storage.list(["feature"]);
@@ -16325,8 +16726,8 @@ async function getPackageData(repoPath) {
     scripts: {}
   };
   try {
-    const pkgPath = path33.join(repoPath, "package.json");
-    const pkg = JSON.parse(await fs32.readFile(pkgPath, "utf-8"));
+    const pkgPath = path34.join(repoPath, "package.json");
+    const pkg = JSON.parse(await fs33.readFile(pkgPath, "utf-8"));
     data.dependencies = pkg.dependencies || {};
     data.devDependencies = pkg.devDependencies || {};
     data.scripts = pkg.scripts || {};
@@ -16335,7 +16736,7 @@ async function getPackageData(repoPath) {
   return data;
 }
 async function generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath) {
-  const projectName = project.name || path33.basename(repoPath);
+  const projectName = project.name || path34.basename(repoPath);
   const currentTask = tasks.find((t) => t.status === "in_progress");
   const pendingTasks = tasks.filter((t) => t.status === "pending");
   const activeFeatures = features.filter((f) => f.status === "in_progress" || f.status === "active");
@@ -16410,7 +16811,7 @@ ${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || "Specialis
     \u2514\u2500\u2500 pending.json
 \`\`\`
 `;
-  await fs32.writeFile(path33.join(contextPath, "CLAUDE.md"), content, "utf-8");
+  await fs33.writeFile(path34.join(contextPath, "CLAUDE.md"), content, "utf-8");
 }
 async function generateNowMd(contextPath, tasks) {
   const currentTask = tasks.find((t) => t.status === "in_progress");
@@ -16425,7 +16826,7 @@ async function generateNowMd(contextPath, tasks) {
 
 _No active task. Use /p:now to start._
 `;
-  await fs32.writeFile(path33.join(contextPath, "now.md"), content, "utf-8");
+  await fs33.writeFile(path34.join(contextPath, "now.md"), content, "utf-8");
 }
 async function generateQueueMd(contextPath, tasks) {
   const pendingTasks = tasks.filter((t) => t.status === "pending");
@@ -16433,7 +16834,7 @@ async function generateQueueMd(contextPath, tasks) {
 
 ${pendingTasks.length > 0 ? pendingTasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ""}`).join("\n") : "_Empty queue. Use /p:next to add tasks._"}
 `;
-  await fs32.writeFile(path33.join(contextPath, "queue.md"), content, "utf-8");
+  await fs33.writeFile(path34.join(contextPath, "queue.md"), content, "utf-8");
 }
 async function generateSummaryMd(contextPath, project, gitData, pkgData) {
   const content = `# PROJECT SUMMARY
@@ -16453,7 +16854,7 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 - Production: ${Object.keys(pkgData.dependencies).length}
 - Dev: ${Object.keys(pkgData.devDependencies).length}
 `;
-  await fs32.writeFile(path33.join(contextPath, "summary.md"), content, "utf-8");
+  await fs33.writeFile(path34.join(contextPath, "summary.md"), content, "utf-8");
 }
 var execAsync4;
 var init_generator = __esm({
@@ -16474,8 +16875,8 @@ var init_generator = __esm({
 
 // core/domain/analyzer.ts
 import { exec as execCallback5 } from "node:child_process";
-import fs33 from "node:fs/promises";
-import path34 from "node:path";
+import fs34 from "node:fs/promises";
+import path35 from "node:path";
 import { promisify as promisify9 } from "node:util";
 var exec9, CodebaseAnalyzer, analyzer, analyzer_default2;
 var init_analyzer2 = __esm({
@@ -16499,8 +16900,8 @@ var init_analyzer2 = __esm({
        */
       async readPackageJson() {
         try {
-          const packagePath = path34.join(this.projectPath, "package.json");
-          const content = await fs33.readFile(packagePath, "utf-8");
+          const packagePath = path35.join(this.projectPath, "package.json");
+          const content = await fs34.readFile(packagePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -16514,8 +16915,8 @@ var init_analyzer2 = __esm({
        */
       async readCargoToml() {
         try {
-          const cargoPath = path34.join(this.projectPath, "Cargo.toml");
-          return await fs33.readFile(cargoPath, "utf-8");
+          const cargoPath = path35.join(this.projectPath, "Cargo.toml");
+          return await fs34.readFile(cargoPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -16528,8 +16929,8 @@ var init_analyzer2 = __esm({
        */
       async readRequirements() {
         try {
-          const reqPath = path34.join(this.projectPath, "requirements.txt");
-          return await fs33.readFile(reqPath, "utf-8");
+          const reqPath = path35.join(this.projectPath, "requirements.txt");
+          return await fs34.readFile(reqPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -16542,8 +16943,8 @@ var init_analyzer2 = __esm({
        */
       async readGoMod() {
         try {
-          const goModPath = path34.join(this.projectPath, "go.mod");
-          return await fs33.readFile(goModPath, "utf-8");
+          const goModPath = path35.join(this.projectPath, "go.mod");
+          return await fs34.readFile(goModPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -16556,8 +16957,8 @@ var init_analyzer2 = __esm({
        */
       async readGemfile() {
         try {
-          const gemfilePath = path34.join(this.projectPath, "Gemfile");
-          return await fs33.readFile(gemfilePath, "utf-8");
+          const gemfilePath = path35.join(this.projectPath, "Gemfile");
+          return await fs34.readFile(gemfilePath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -16570,8 +16971,8 @@ var init_analyzer2 = __esm({
        */
       async readMixExs() {
         try {
-          const mixPath = path34.join(this.projectPath, "mix.exs");
-          return await fs33.readFile(mixPath, "utf-8");
+          const mixPath = path35.join(this.projectPath, "mix.exs");
+          return await fs34.readFile(mixPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -16584,8 +16985,8 @@ var init_analyzer2 = __esm({
        */
       async readPomXml() {
         try {
-          const pomPath = path34.join(this.projectPath, "pom.xml");
-          return await fs33.readFile(pomPath, "utf-8");
+          const pomPath = path35.join(this.projectPath, "pom.xml");
+          return await fs34.readFile(pomPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -16598,8 +16999,8 @@ var init_analyzer2 = __esm({
        */
       async readComposerJson() {
         try {
-          const composerPath = path34.join(this.projectPath, "composer.json");
-          const content = await fs33.readFile(composerPath, "utf-8");
+          const composerPath = path35.join(this.projectPath, "composer.json");
+          const content = await fs34.readFile(composerPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -16613,8 +17014,8 @@ var init_analyzer2 = __esm({
        */
       async readPyprojectToml() {
         try {
-          const pyprojectPath = path34.join(this.projectPath, "pyproject.toml");
-          return await fs33.readFile(pyprojectPath, "utf-8");
+          const pyprojectPath = path35.join(this.projectPath, "pyproject.toml");
+          return await fs34.readFile(pyprojectPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -16650,7 +17051,7 @@ var init_analyzer2 = __esm({
        */
       async listConfigFiles() {
         try {
-          const entries = await fs33.readdir(this.projectPath);
+          const entries = await fs34.readdir(this.projectPath);
           const configPatterns = [
             /^package\.json$/,
             /^Cargo\.toml$/,
@@ -16680,7 +17081,7 @@ var init_analyzer2 = __esm({
        */
       async listDirectories() {
         try {
-          const entries = await fs33.readdir(this.projectPath, { withFileTypes: true });
+          const entries = await fs34.readdir(this.projectPath, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -16751,7 +17152,7 @@ var init_analyzer2 = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs33.access(path34.join(this.projectPath, filename));
+          await fs34.access(path35.join(this.projectPath, filename));
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -16765,8 +17166,8 @@ var init_analyzer2 = __esm({
        */
       async readFile(relativePath) {
         try {
-          const fullPath = path34.join(this.projectPath, relativePath);
-          return await fs33.readFile(fullPath, "utf-8");
+          const fullPath = path35.join(this.projectPath, relativePath);
+          return await fs34.readFile(fullPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -17014,8 +17415,8 @@ var analysis_exports = {};
 __export(analysis_exports, {
   AnalysisCommands: () => AnalysisCommands
 });
-import fs34 from "node:fs/promises";
-import path35 from "node:path";
+import fs35 from "node:fs/promises";
+import path36 from "node:path";
 import prompts2 from "prompts";
 var AnalysisCommands;
 var init_analysis2 = __esm({
@@ -17102,7 +17503,7 @@ var init_analysis2 = __esm({
         lines.push("# Repository Analysis\n");
         lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
 `);
-        const projectName = path35.basename(projectPath);
+        const projectName = path36.basename(projectPath);
         lines.push(`## Project: ${projectName}
 `);
         lines.push("## Stack Detected\n");
@@ -17210,10 +17611,42 @@ var init_analysis2 = __esm({
           }
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
           const startTime = Date.now();
-          const claudeMdPath = path35.join(globalPath, "context", "CLAUDE.md");
+          if (options.package) {
+            const monoInfo = await path_manager_default.detectMonorepo(projectPath);
+            if (!monoInfo.isMonorepo) {
+              return {
+                success: false,
+                error: "Not a monorepo. --package flag only works in monorepos."
+              };
+            }
+            const pkg = monoInfo.packages.find(
+              (p) => p.name === options.package || p.relativePath === options.package
+            );
+            if (!pkg) {
+              const available = monoInfo.packages.map((p) => p.name).join(", ");
+              return {
+                success: false,
+                error: `Package "${options.package}" not found. Available: ${available}`
+              };
+            }
+            const result2 = await syncService.sync(projectPath, {
+              aiTools: options.aiTools,
+              packagePath: pkg.path,
+              packageName: pkg.name
+            });
+            if (options.json) {
+              console.log(
+                JSON.stringify({ success: result2.success, package: pkg.name, path: pkg.relativePath })
+              );
+            } else {
+              output_default.done(`Synced package: ${pkg.name}`);
+            }
+            return { success: result2.success };
+          }
+          const claudeMdPath = path36.join(globalPath, "context", "CLAUDE.md");
           let existingContent = null;
           try {
-            existingContent = await fs34.readFile(claudeMdPath, "utf-8");
+            existingContent = await fs35.readFile(claudeMdPath, "utf-8");
           } catch {
           }
           const isNonInteractive = !process.stdin.isTTY || options.json;
@@ -17232,7 +17665,7 @@ var init_analysis2 = __esm({
             }
             let newContent;
             try {
-              newContent = await fs34.readFile(claudeMdPath, "utf-8");
+              newContent = await fs35.readFile(claudeMdPath, "utf-8");
             } catch {
               newContent = "";
             }
@@ -17463,7 +17896,7 @@ ${formatFullDiff(diff)}`);
           let projectName = "Unknown";
           try {
             const projectJson = JSON.parse(
-              await fs34.readFile(path35.join(globalPath, "project.json"), "utf-8")
+              await fs35.readFile(path36.join(globalPath, "project.json"), "utf-8")
             );
             projectName = projectJson.name || "Unknown";
           } catch {
@@ -17714,7 +18147,7 @@ var planning_exports = {};
 __export(planning_exports, {
   PlanningCommands: () => PlanningCommands
 });
-import path36 from "node:path";
+import path37 from "node:path";
 async function getAnalysisCommands() {
   if (!_analysisCommands) {
     const { AnalysisCommands: AnalysisCommands2 } = await Promise.resolve().then(() => (init_analysis2(), analysis_exports));
@@ -17821,7 +18254,7 @@ var init_planning = __esm({
             );
           }
           for (const [filePath, content] of Object.entries(baseFiles)) {
-            await tool_registry_default.get("Write")(path36.join(globalPath, filePath), content);
+            await tool_registry_default.get("Write")(path37.join(globalPath, filePath), content);
           }
           const isEmpty = await this._detectEmptyDirectory(projectPath);
           const hasCode = await this._detectExistingCode(projectPath);
@@ -17848,7 +18281,7 @@ var init_planning = __esm({
               return { success: true, mode: "blank_no_idea", projectId, wizard: wizardResult };
             }
             output_default.spin("architect mode...");
-            const sessionPath = path36.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path37.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -18033,7 +18466,7 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!initResult.success) return initResult;
           console.log("\u{1F3D7}\uFE0F  Architect Mode - Code Generation\n");
           const globalPath = await this.getGlobalProjectPath(projectPath);
-          const planPath = path36.join(globalPath, "planning", "architect-session.md");
+          const planPath = path37.join(globalPath, "planning", "architect-session.md");
           let planContent;
           try {
             planContent = await file_helper_exports.readFile(planPath);
@@ -18108,7 +18541,7 @@ ${"=".repeat(60)}`);
           if (isComplex) {
             output_default.spin("analyzing idea...");
             const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-            const sessionPath = path36.join(globalPath, "planning", "architect-session.md");
+            const sessionPath = path37.join(globalPath, "planning", "architect-session.md");
             const sessionContent = `# Architect Session
 
 ## Idea
@@ -18164,10 +18597,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           if (!featureName) {
             output_default.spin("loading specs...");
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
-            const specsPath2 = path36.join(globalPath2, "planning", "specs");
+            const specsPath2 = path37.join(globalPath2, "planning", "specs");
             try {
-              const fs47 = await import("node:fs/promises");
-              const files = await fs47.readdir(specsPath2);
+              const fs48 = await import("node:fs/promises");
+              const files = await fs48.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -18190,10 +18623,10 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
           }
           output_default.spin("creating spec...");
           const globalPath = path_manager_default.getGlobalProjectPath(projectId);
-          const specsPath = path36.join(globalPath, "planning", "specs");
+          const specsPath = path37.join(globalPath, "planning", "specs");
           await file_helper_exports.ensureDir(specsPath);
           const slug = featureName.toLowerCase().replace(/\s+/g, "-");
-          const specFile = path36.join(specsPath, `${slug}.md`);
+          const specFile = path37.join(specsPath, `${slug}.md`);
           const specContent = `# Specification: ${featureName}
 
 ## Overview
@@ -18598,9 +19031,9 @@ var init_formatters = __esm({
 
 // core/ai-tools/registry.ts
 import { execSync as execSync4 } from "node:child_process";
-import fs35 from "node:fs";
+import fs36 from "node:fs";
 import os11 from "node:os";
-import path37 from "node:path";
+import path38 from "node:path";
 function getAIToolConfig(id) {
   return AI_TOOLS[id] || null;
 }
@@ -18617,16 +19050,16 @@ function detectInstalledTools(repoPath = process.cwd()) {
   if (commandExists("claude")) {
     detected.push("claude");
   }
-  if (commandExists("cursor") || fs35.existsSync(path37.join(repoPath, ".cursor"))) {
+  if (commandExists("cursor") || fs36.existsSync(path38.join(repoPath, ".cursor"))) {
     detected.push("cursor");
   }
-  if (fs35.existsSync(path37.join(repoPath, ".github"))) {
+  if (fs36.existsSync(path38.join(repoPath, ".github"))) {
     detected.push("copilot");
   }
-  if (commandExists("windsurf") || fs35.existsSync(path37.join(repoPath, ".windsurf"))) {
+  if (commandExists("windsurf") || fs36.existsSync(path38.join(repoPath, ".windsurf"))) {
     detected.push("windsurf");
   }
-  if (fs35.existsSync(path37.join(repoPath, ".continue")) || fs35.existsSync(path37.join(os11.homedir(), ".continue"))) {
+  if (fs36.existsSync(path38.join(repoPath, ".continue")) || fs36.existsSync(path38.join(os11.homedir(), ".continue"))) {
     detected.push("continue");
   }
   return detected;
@@ -18702,8 +19135,8 @@ var init_registry = __esm({
 });
 
 // core/ai-tools/generator.ts
-import fs36 from "node:fs/promises";
-import path38 from "node:path";
+import fs37 from "node:fs/promises";
+import path39 from "node:path";
 async function generateAIToolContexts(context2, globalPath, repoPath, toolIds = DEFAULT_AI_TOOLS) {
   const results = [];
   for (const toolId of toolIds) {
@@ -18738,13 +19171,13 @@ async function generateForTool(context2, config, globalPath, repoPath) {
     let content = formatter(context2, config);
     let outputPath;
     if (config.outputPath === "repo") {
-      outputPath = path38.join(repoPath, config.outputFile);
+      outputPath = path39.join(repoPath, config.outputFile);
     } else {
-      outputPath = path38.join(globalPath, "context", config.outputFile);
+      outputPath = path39.join(globalPath, "context", config.outputFile);
     }
-    await fs36.mkdir(path38.dirname(outputPath), { recursive: true });
+    await fs37.mkdir(path39.dirname(outputPath), { recursive: true });
     try {
-      const existingContent = await fs36.readFile(outputPath, "utf-8");
+      const existingContent = await fs37.readFile(outputPath, "utf-8");
       const validation = validatePreserveBlocks(existingContent);
       if (!validation.valid) {
         console.warn(`\u26A0\uFE0F  ${config.outputFile} has invalid preserve blocks:`);
@@ -18755,7 +19188,7 @@ async function generateForTool(context2, config, globalPath, repoPath) {
       content = mergePreservedSections(content, existingContent);
     } catch {
     }
-    await fs36.writeFile(outputPath, content, "utf-8");
+    await fs37.writeFile(outputPath, content, "utf-8");
     return {
       toolId: config.id,
       outputFile: config.outputFile,
@@ -18794,14 +19227,16 @@ var init_ai_tools = __esm({
 });
 
 // core/services/context-generator.ts
-import fs37 from "node:fs/promises";
-import path39 from "node:path";
+import fs38 from "node:fs/promises";
+import path40 from "node:path";
 var ContextFileGenerator;
 var init_context_generator = __esm({
   "core/services/context-generator.ts"() {
     "use strict";
+    init_path_manager();
     init_date_helper();
     init_preserve_sections();
+    init_nested_context_resolver();
     ContextFileGenerator = class {
       static {
         __name(this, "ContextFileGenerator");
@@ -18817,10 +19252,10 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs37.readFile(filePath, "utf-8");
+          const existingContent = await fs38.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
-            const filename = path39.basename(filePath);
+            const filename = path40.basename(filePath);
             console.warn(`\u26A0\uFE0F  ${filename} has invalid preserve blocks:`);
             for (const error of validation.errors) {
               console.warn(`   ${error}`);
@@ -18829,13 +19264,13 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs37.writeFile(filePath, finalContent, "utf-8");
+        await fs38.writeFile(filePath, finalContent, "utf-8");
       }
       /**
        * Generate all context files in parallel
        */
       async generate(git, stats, commands, agents) {
-        const contextPath = path39.join(this.config.globalPath, "context");
+        const contextPath = path40.join(this.config.globalPath, "context");
         await Promise.all([
           this.generateClaudeMd(contextPath, git, stats, commands, agents),
           this.generateNowMd(contextPath),
@@ -18929,7 +19364,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        const claudePath = path39.join(contextPath, "CLAUDE.md");
+        const claudePath = path40.join(contextPath, "CLAUDE.md");
         await this.writeWithPreservation(claudePath, content);
       }
       /**
@@ -18938,8 +19373,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path39.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs37.readFile(statePath, "utf-8"));
+          const statePath = path40.join(this.config.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs38.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -18955,7 +19390,7 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await this.writeWithPreservation(path39.join(contextPath, "now.md"), content);
+        await this.writeWithPreservation(path40.join(contextPath, "now.md"), content);
       }
       /**
        * Generate next.md - task queue
@@ -18963,15 +19398,15 @@ Use \`p. task "description"\` to start working.
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path39.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs37.readFile(queuePath, "utf-8"));
+          const queuePath = path40.join(this.config.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs38.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(path39.join(contextPath, "next.md"), content);
+        await this.writeWithPreservation(path40.join(contextPath, "next.md"), content);
       }
       /**
        * Generate ideas.md - captured ideas
@@ -18979,15 +19414,15 @@ ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}
       async generateIdeasMd(contextPath) {
         let ideas = { ideas: [] };
         try {
-          const ideasPath = path39.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs37.readFile(ideasPath, "utf-8"));
+          const ideasPath = path40.join(this.config.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs38.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(path39.join(contextPath, "ideas.md"), content);
+        await this.writeWithPreservation(path40.join(contextPath, "ideas.md"), content);
       }
       /**
        * Generate shipped.md - completed features
@@ -18997,8 +19432,8 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
           shipped: []
         };
         try {
-          const shippedPath = path39.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs37.readFile(shippedPath, "utf-8"));
+          const shippedPath = path40.join(this.config.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs38.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -19007,15 +19442,118 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await this.writeWithPreservation(path39.join(contextPath, "shipped.md"), content);
+        await this.writeWithPreservation(path40.join(contextPath, "shipped.md"), content);
+      }
+      // ==========================================================================
+      // MONOREPO SUPPORT
+      // ==========================================================================
+      /**
+       * Generate CLAUDE.md files for each package in a monorepo
+       * Each package gets its own context file with inherited + package-specific rules
+       */
+      async generateMonorepoContexts(git, stats, commands, agents) {
+        const monoInfo = await path_manager_default.detectMonorepo(this.config.projectPath);
+        if (!monoInfo.isMonorepo) {
+          return [];
+        }
+        const generatedFiles = [];
+        const resolver = new NestedContextResolver(this.config.projectPath);
+        await resolver.initialize();
+        for (const pkg of monoInfo.packages) {
+          if (!pkg.hasPrjctMd) continue;
+          const resolvedCtx = await resolver.getPackageContext(pkg.name);
+          if (!resolvedCtx) continue;
+          const content = await this.generatePackageClaudeMd(
+            pkg,
+            resolvedCtx,
+            git,
+            stats,
+            commands,
+            agents
+          );
+          const claudePath = path40.join(pkg.path, "CLAUDE.md");
+          await this.writeWithPreservation(claudePath, content);
+          generatedFiles.push(path40.relative(this.config.projectPath, claudePath));
+        }
+        return generatedFiles;
+      }
+      /**
+       * Generate CLAUDE.md content for a specific package
+       */
+      async generatePackageClaudeMd(pkg, resolvedCtx, git, stats, commands, agents) {
+        const workflowAgents = agents.filter((a) => a.type === "workflow").map((a) => a.name);
+        const domainAgents = agents.filter((a) => a.type === "domain").map((a) => a.name);
+        let pkgVersion = stats.version;
+        let pkgName = pkg.name;
+        try {
+          const pkgJsonPath = path40.join(pkg.path, "package.json");
+          const pkgJson = JSON.parse(await fs38.readFile(pkgJsonPath, "utf-8"));
+          pkgVersion = pkgJson.version || stats.version;
+          pkgName = pkgJson.name || pkg.name;
+        } catch {
+        }
+        return `# ${pkgName} - Package Rules
+<!-- package: ${pkg.relativePath} -->
+<!-- monorepo: ${stats.name} -->
+<!-- Generated: ${date_helper_default.getTimestamp()} -->
+<!-- Sources: ${resolvedCtx.sources.join(" \u2192 ")} -->
+
+## THIS PACKAGE
+
+**Name:** ${pkgName}
+**Path:** ${pkg.relativePath}
+**Version:** ${pkgVersion}
+**Monorepo:** ${stats.name}
+
+---
+
+## INHERITED CONTEXT
+
+${resolvedCtx.content || "_No PRJCT.md rules defined_"}
+
+${resolvedCtx.overrides.length > 0 ? `
+**Overrides:** ${resolvedCtx.overrides.join(", ")}
+` : ""}
+
+---
+
+## COMMANDS
+
+| Action | Command |
+|--------|---------|
+| Install | \`${commands.install}\` |
+| Dev | \`${commands.dev}\` |
+| Test | \`${commands.test}\` |
+| Build | \`${commands.build}\` |
+
+---
+
+## PROJECT STATE
+
+| Field | Value |
+|-------|-------|
+| Package | ${pkgName} |
+| Monorepo | ${stats.name} |
+| Branch | ${git.branch} |
+| Ecosystem | ${stats.ecosystem} |
+
+---
+
+## AGENTS
+
+Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
+
+**Workflow**: ${workflowAgents.join(", ")}
+**Domain**: ${domainAgents.join(", ") || "none"}
+`;
       }
     };
   }
 });
 
 // core/services/stack-detector.ts
-import fs38 from "node:fs/promises";
-import path40 from "node:path";
+import fs39 from "node:fs/promises";
+import path41 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -19174,8 +19712,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path40.join(this.projectPath, "package.json");
-          const content = await fs38.readFile(pkgPath, "utf-8");
+          const pkgPath = path41.join(this.projectPath, "package.json");
+          const content = await fs39.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -19186,7 +19724,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs38.access(path40.join(this.projectPath, filename));
+          await fs39.access(path41.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -19198,8 +19736,8 @@ var init_stack_detector = __esm({
 
 // core/services/sync-service.ts
 import { exec as exec10 } from "node:child_process";
-import fs39 from "node:fs/promises";
-import path41 from "node:path";
+import fs40 from "node:fs/promises";
+import path42 from "node:path";
 import { promisify as promisify10 } from "node:util";
 var execAsync5, SyncService, syncService;
 var init_sync_service = __esm({
@@ -19348,7 +19886,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs39.mkdir(path41.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs40.mkdir(path42.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -19418,7 +19956,7 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path41.basename(this.projectPath),
+          name: path42.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
@@ -19434,8 +19972,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path41.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs39.readFile(pkgPath, "utf-8"));
+          const pkgPath = path42.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs40.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -19543,12 +20081,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path41.join(this.globalPath, "agents");
+        const agentsPath = path42.join(this.globalPath, "agents");
         try {
-          const files = await fs39.readdir(agentsPath);
+          const files = await fs40.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs39.unlink(path41.join(agentsPath, file));
+              await fs40.unlink(path42.join(agentsPath, file));
             }
           }
         } catch {
@@ -19588,7 +20126,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path41.join(
+          const templatePath = path42.join(
             __dirname,
             "..",
             "..",
@@ -19597,16 +20135,16 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs39.readFile(templatePath, "utf-8");
+          content = await fs40.readFile(templatePath, "utf-8");
         } catch {
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs39.writeFile(path41.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs40.writeFile(path42.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path41.join(
+          const templatePath = path42.join(
             __dirname,
             "..",
             "..",
@@ -19615,14 +20153,14 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs39.readFile(templatePath, "utf-8");
+          content = await fs40.readFile(templatePath, "utf-8");
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
           content = content.replace("{ecosystem}", stats.ecosystem);
         } catch {
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs39.writeFile(path41.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs40.writeFile(path42.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -19690,8 +20228,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]))
         };
-        fs39.writeFile(
-          path41.join(this.globalPath, "config", "skills.json"),
+        fs40.writeFile(
+          path42.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch(() => {
@@ -19713,10 +20251,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path41.join(this.globalPath, "project.json");
+        const projectJsonPath = path42.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs39.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs40.readFile(projectJsonPath, "utf-8"));
         } catch {
         }
         const updated = {
@@ -19735,16 +20273,16 @@ You are the ${name} expert for this project. Apply best practices for the detect
           createdAt: existing.createdAt || date_helper_default.getTimestamp(),
           lastSync: date_helper_default.getTimestamp()
         };
-        await fs39.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs40.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path41.join(this.globalPath, "storage", "state.json");
+        const statePath = path42.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs39.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs40.readFile(statePath, "utf-8"));
         } catch {
         }
         state.projectId = this.projectId;
@@ -19771,13 +20309,13 @@ 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 fs39.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs40.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
       }
       // ==========================================================================
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path41.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path42.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: date_helper_default.getTimestamp(),
           action: "sync",
@@ -19786,7 +20324,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs39.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs40.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -19806,16 +20344,16 @@ You are the ${name} expert for this project. Apply best practices for the detect
         let filteredChars = 0;
         for (const file of contextFiles) {
           try {
-            const filePath = path41.join(this.globalPath, file);
-            const content = await fs39.readFile(filePath, "utf-8");
+            const filePath = path42.join(this.globalPath, file);
+            const content = await fs40.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
         }
         for (const agent of agents) {
           try {
-            const agentPath = path41.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs39.readFile(agentPath, "utf-8");
+            const agentPath = path42.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs40.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
@@ -19847,7 +20385,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs39.access(path41.join(this.projectPath, filename));
+          await fs40.access(path42.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -19855,8 +20393,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path41.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs39.readFile(pkgPath, "utf-8"));
+          const pkgPath = path42.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs40.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch {
           return "0.0.0";
@@ -19926,6 +20464,7 @@ var init_services = __esm({
     init_file_scorer();
     init_git_analyzer();
     init_memory_service();
+    init_nested_context_resolver();
     init_project_index();
     init_project_service();
     init_sync_service();
@@ -20015,22 +20554,22 @@ __export(uninstall_exports, {
 });
 import { execSync as execSync5 } from "node:child_process";
 import fsSync2 from "node:fs";
-import fs40 from "node:fs/promises";
+import fs41 from "node:fs/promises";
 import os12 from "node:os";
-import path42 from "node:path";
+import path43 from "node:path";
 import readline2 from "node:readline";
 import chalk9 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs40.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs41.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path42.join(dirPath, entry.name);
+      const entryPath = path43.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs40.stat(entryPath);
+          const stats = await fs41.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -20049,7 +20588,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs40.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs41.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -20082,7 +20621,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = fsSync2.existsSync(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path42.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path43.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -20092,7 +20631,7 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path42.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path43.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = fsSync2.existsSync(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
@@ -20126,7 +20665,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path42.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path43.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = fsSync2.existsSync(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -20142,7 +20681,7 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path42.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path43.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = fsSync2.existsSync(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
@@ -20164,7 +20703,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs40.readFile(filePath, "utf-8");
+    const content = await fs41.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -20173,9 +20712,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 fs40.unlink(filePath);
+      await fs41.unlink(filePath);
     } else {
-      await fs40.writeFile(filePath, `${newContent}
+      await fs41.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -20186,12 +20725,12 @@ async function removePrjctSection(filePath) {
 async function createBackup() {
   const homeDir = os12.homedir();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
-  const backupDir = path42.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path43.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs40.mkdir(backupDir, { recursive: true });
+    await fs41.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (fsSync2.existsSync(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path42.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path43.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -20199,15 +20738,15 @@ async function createBackup() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs40.mkdir(dest, { recursive: true });
-  const entries = await fs40.readdir(src, { withFileTypes: true });
+  await fs41.mkdir(dest, { recursive: true });
+  const entries = await fs41.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path42.join(src, entry.name);
-    const destPath = path42.join(dest, entry.name);
+    const srcPath = path43.join(src, entry.name);
+    const destPath = path43.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs40.copyFile(srcPath, destPath);
+      await fs41.copyFile(srcPath, destPath);
     }
   }
 }
@@ -20223,10 +20762,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs40.rm(item.path, { recursive: true, force: true });
+        await fs41.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs40.unlink(item.path);
+        await fs41.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -20401,7 +20940,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path43 from "node:path";
+import path44 from "node:path";
 import chalk10 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -20606,7 +21145,7 @@ ${chalk10.dim(`[${timestamp}]`)} ${chalk10.cyan("\u27F3")} ${filesSummary} chang
       printStartup() {
         console.log("");
         console.log(chalk10.cyan("\u{1F441}\uFE0F  Watching for changes..."));
-        console.log(chalk10.dim(`   Project: ${path43.basename(this.projectPath)}`));
+        console.log(chalk10.dim(`   Project: ${path44.basename(this.projectPath)}`));
         console.log(chalk10.dim(`   Debounce: ${this.options.debounceMs}ms`));
         console.log(chalk10.dim(`   Min interval: ${this.options.minIntervalMs / 1e3}s`));
         console.log("");
@@ -20779,10 +21318,15 @@ var init_command_data = __esm({
         name: "sync",
         group: "core",
         description: "Sync project state and update workflow agents",
-        usage: { claude: "/p:sync", terminal: "prjct sync" },
+        usage: { claude: "/p:sync", terminal: "prjct sync [--package=<name>]" },
         implemented: true,
         hasTemplate: true,
-        requiresProject: true
+        requiresProject: true,
+        features: [
+          "Monorepo support: --package=<name> for single package sync",
+          "Nested PRJCT.md inheritance",
+          "Per-package CLAUDE.md generation"
+        ]
       },
       {
         name: "suggest",
@@ -21258,9 +21802,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync6 } from "node:child_process";
-import fs41 from "node:fs";
+import fs42 from "node:fs";
 import os13 from "node:os";
-import path44 from "node:path";
+import path45 from "node:path";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
   try {
@@ -21366,12 +21910,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    const geminiCommandsDir = path44.join(os13.homedir(), ".gemini", "commands");
-    const routerSource = path44.join(getPackageRoot(), "templates", "commands", "p.toml");
-    const routerDest = path44.join(geminiCommandsDir, "p.toml");
-    fs41.mkdirSync(geminiCommandsDir, { recursive: true });
-    if (fs41.existsSync(routerSource)) {
-      fs41.copyFileSync(routerSource, routerDest);
+    const geminiCommandsDir = path45.join(os13.homedir(), ".gemini", "commands");
+    const routerSource = path45.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = path45.join(geminiCommandsDir, "p.toml");
+    fs42.mkdirSync(geminiCommandsDir, { recursive: true });
+    if (fs42.existsSync(routerSource)) {
+      fs42.copyFileSync(routerSource, routerDest);
       return true;
     }
     return false;
@@ -21382,15 +21926,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    const geminiDir = path44.join(os13.homedir(), ".gemini");
-    const globalConfigPath = path44.join(geminiDir, "GEMINI.md");
-    const templatePath = path44.join(getPackageRoot(), "templates", "global", "GEMINI.md");
-    fs41.mkdirSync(geminiDir, { recursive: true });
-    const templateContent = fs41.readFileSync(templatePath, "utf-8");
+    const geminiDir = path45.join(os13.homedir(), ".gemini");
+    const globalConfigPath = path45.join(geminiDir, "GEMINI.md");
+    const templatePath = path45.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    fs42.mkdirSync(geminiDir, { recursive: true });
+    const templateContent = fs42.readFileSync(templatePath, "utf-8");
     let existingContent = "";
     let fileExists2 = false;
     try {
-      existingContent = fs41.readFileSync(globalConfigPath, "utf-8");
+      existingContent = fs42.readFileSync(globalConfigPath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -21400,7 +21944,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!fileExists2) {
-      fs41.writeFileSync(globalConfigPath, templateContent, "utf-8");
+      fs42.writeFileSync(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -21410,7 +21954,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      fs41.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
+      fs42.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -21422,7 +21966,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    fs41.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    fs42.writeFileSync(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -21431,18 +21975,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    const antigravitySkillsDir = path44.join(os13.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = path44.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = path44.join(prjctSkillDir, "SKILL.md");
-    const templatePath = path44.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
-    fs41.mkdirSync(prjctSkillDir, { recursive: true });
-    const fileExists2 = fs41.existsSync(skillMdPath);
-    if (!fs41.existsSync(templatePath)) {
+    const antigravitySkillsDir = path45.join(os13.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path45.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path45.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path45.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    fs42.mkdirSync(prjctSkillDir, { recursive: true });
+    const fileExists2 = fs42.existsSync(skillMdPath);
+    if (!fs42.existsSync(templatePath)) {
       console.error("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = fs41.readFileSync(templatePath, "utf-8");
-    fs41.writeFileSync(skillMdPath, templateContent, "utf-8");
+    const templateContent = fs42.readFileSync(templatePath, "utf-8");
+    fs42.writeFileSync(skillMdPath, templateContent, "utf-8");
     return { success: true, action: fileExists2 ? "updated" : "created" };
   } catch (error) {
     console.error(`Antigravity skill warning: ${error.message}`);
@@ -21461,24 +22005,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const cursorDir = path44.join(projectRoot, ".cursor");
-    const rulesDir = path44.join(cursorDir, "rules");
-    const commandsDir = path44.join(cursorDir, "commands");
-    const routerMdcDest = path44.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = path44.join(getPackageRoot(), "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = path44.join(getPackageRoot(), "templates", "cursor", "commands");
-    fs41.mkdirSync(rulesDir, { recursive: true });
-    fs41.mkdirSync(commandsDir, { recursive: true });
-    if (fs41.existsSync(routerMdcSource)) {
-      fs41.copyFileSync(routerMdcSource, routerMdcDest);
+    const cursorDir = path45.join(projectRoot, ".cursor");
+    const rulesDir = path45.join(cursorDir, "rules");
+    const commandsDir = path45.join(cursorDir, "commands");
+    const routerMdcDest = path45.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path45.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path45.join(getPackageRoot(), "templates", "cursor", "commands");
+    fs42.mkdirSync(rulesDir, { recursive: true });
+    fs42.mkdirSync(commandsDir, { recursive: true });
+    if (fs42.existsSync(routerMdcSource)) {
+      fs42.copyFileSync(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
-    if (fs41.existsSync(cursorCommandsSource)) {
-      const commandFiles = fs41.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
+    if (fs42.existsSync(cursorCommandsSource)) {
+      const commandFiles = fs42.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path44.join(cursorCommandsSource, file);
-        const dest = path44.join(commandsDir, file);
-        fs41.copyFileSync(src, dest);
+        const src = path45.join(cursorCommandsSource, file);
+        const dest = path45.join(commandsDir, file);
+        fs42.copyFileSync(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -21492,7 +22036,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path44.join(projectRoot, ".gitignore");
+    const gitignorePath = path45.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -21507,7 +22051,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs41.readFileSync(gitignorePath, "utf-8");
+      content = fs42.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -21522,7 +22066,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs41.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs42.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -21530,12 +22074,12 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasCursorProject(projectRoot) {
-  return fs41.existsSync(path44.join(projectRoot, ".cursor"));
+  return fs42.existsSync(path45.join(projectRoot, ".cursor"));
 }
 function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path44.join(projectRoot, ".cursor");
-  const routerPath = path44.join(cursorDir, "rules", "prjct.mdc");
-  return fs41.existsSync(cursorDir) && !fs41.existsSync(routerPath);
+  const cursorDir = path45.join(projectRoot, ".cursor");
+  const routerPath = path45.join(cursorDir, "rules", "prjct.mdc");
+  return fs42.existsSync(cursorDir) && !fs42.existsSync(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
   const result = {
@@ -21545,29 +22089,29 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    const windsurfDir = path44.join(projectRoot, ".windsurf");
-    const rulesDir = path44.join(windsurfDir, "rules");
-    const workflowsDir = path44.join(windsurfDir, "workflows");
-    const routerDest = path44.join(rulesDir, "prjct.md");
-    const routerSource = path44.join(getPackageRoot(), "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = path44.join(
+    const windsurfDir = path45.join(projectRoot, ".windsurf");
+    const rulesDir = path45.join(windsurfDir, "rules");
+    const workflowsDir = path45.join(windsurfDir, "workflows");
+    const routerDest = path45.join(rulesDir, "prjct.md");
+    const routerSource = path45.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path45.join(
       getPackageRoot(),
       "templates",
       "windsurf",
       "workflows"
     );
-    fs41.mkdirSync(rulesDir, { recursive: true });
-    fs41.mkdirSync(workflowsDir, { recursive: true });
-    if (fs41.existsSync(routerSource)) {
-      fs41.copyFileSync(routerSource, routerDest);
+    fs42.mkdirSync(rulesDir, { recursive: true });
+    fs42.mkdirSync(workflowsDir, { recursive: true });
+    if (fs42.existsSync(routerSource)) {
+      fs42.copyFileSync(routerSource, routerDest);
       result.rulesCreated = true;
     }
-    if (fs41.existsSync(windsurfWorkflowsSource)) {
-      const workflowFiles = fs41.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
+    if (fs42.existsSync(windsurfWorkflowsSource)) {
+      const workflowFiles = fs42.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
       for (const file of workflowFiles) {
-        const src = path44.join(windsurfWorkflowsSource, file);
-        const dest = path44.join(workflowsDir, file);
-        fs41.copyFileSync(src, dest);
+        const src = path45.join(windsurfWorkflowsSource, file);
+        const dest = path45.join(workflowsDir, file);
+        fs42.copyFileSync(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -21581,7 +22125,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path44.join(projectRoot, ".gitignore");
+    const gitignorePath = path45.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -21596,7 +22140,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs41.readFileSync(gitignorePath, "utf-8");
+      content = fs42.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -21611,7 +22155,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs41.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs42.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -21619,32 +22163,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasWindsurfProject(projectRoot) {
-  return fs41.existsSync(path44.join(projectRoot, ".windsurf"));
+  return fs42.existsSync(path45.join(projectRoot, ".windsurf"));
 }
 function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path44.join(projectRoot, ".windsurf");
-  const routerPath = path44.join(windsurfDir, "rules", "prjct.md");
-  return fs41.existsSync(windsurfDir) && !fs41.existsSync(routerPath);
+  const windsurfDir = path45.join(projectRoot, ".windsurf");
+  const routerPath = path45.join(windsurfDir, "rules", "prjct.md");
+  return fs42.existsSync(windsurfDir) && !fs42.existsSync(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path44.join(os13.homedir(), ".prjct-cli", "projects");
-    if (!fs41.existsSync(projectsDir)) {
+    const projectsDir = path45.join(os13.homedir(), ".prjct-cli", "projects");
+    if (!fs42.existsSync(projectsDir)) {
       return;
     }
-    const projectDirs = fs41.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = fs42.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path44.join(projectsDir, projectId, "project.json");
-      if (!fs41.existsSync(projectJsonPath)) {
+      const projectJsonPath = path45.join(projectsDir, projectId, "project.json");
+      if (!fs42.existsSync(projectJsonPath)) {
         continue;
       }
       try {
-        const content = fs41.readFileSync(projectJsonPath, "utf8");
+        const content = fs42.readFileSync(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          fs41.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          fs42.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -21664,9 +22208,9 @@ async function migrateProjectsCliVersion() {
 }
 function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
-  if (fs41.existsSync(settingsPath)) {
+  if (fs42.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs41.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(fs42.readFileSync(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -21674,42 +22218,42 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  fs41.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  fs42.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    const claudeDir = path44.join(os13.homedir(), ".claude");
-    const settingsPath = path44.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = path44.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = path44.join(os13.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = path44.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = path44.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = path44.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = path44.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = path44.join(prjctStatusLineDir, "config.json");
-    const assetsDir = path44.join(getPackageRoot(), "assets", "statusline");
-    const sourceScript = path44.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = path44.join(assetsDir, "themes");
-    const sourceLibDir = path44.join(assetsDir, "lib");
-    const sourceComponentsDir = path44.join(assetsDir, "components");
-    const sourceConfigPath = path44.join(assetsDir, "default-config.json");
-    if (!fs41.existsSync(claudeDir)) {
-      fs41.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = path45.join(os13.homedir(), ".claude");
+    const settingsPath = path45.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path45.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path45.join(os13.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path45.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path45.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path45.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path45.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path45.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path45.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = path45.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path45.join(assetsDir, "themes");
+    const sourceLibDir = path45.join(assetsDir, "lib");
+    const sourceComponentsDir = path45.join(assetsDir, "components");
+    const sourceConfigPath = path45.join(assetsDir, "default-config.json");
+    if (!fs42.existsSync(claudeDir)) {
+      fs42.mkdirSync(claudeDir, { recursive: true });
     }
-    if (!fs41.existsSync(prjctStatusLineDir)) {
-      fs41.mkdirSync(prjctStatusLineDir, { recursive: true });
+    if (!fs42.existsSync(prjctStatusLineDir)) {
+      fs42.mkdirSync(prjctStatusLineDir, { recursive: true });
     }
-    if (!fs41.existsSync(prjctThemesDir)) {
-      fs41.mkdirSync(prjctThemesDir, { recursive: true });
+    if (!fs42.existsSync(prjctThemesDir)) {
+      fs42.mkdirSync(prjctThemesDir, { recursive: true });
     }
-    if (!fs41.existsSync(prjctLibDir)) {
-      fs41.mkdirSync(prjctLibDir, { recursive: true });
+    if (!fs42.existsSync(prjctLibDir)) {
+      fs42.mkdirSync(prjctLibDir, { recursive: true });
     }
-    if (!fs41.existsSync(prjctComponentsDir)) {
-      fs41.mkdirSync(prjctComponentsDir, { recursive: true });
+    if (!fs42.existsSync(prjctComponentsDir)) {
+      fs42.mkdirSync(prjctComponentsDir, { recursive: true });
     }
-    if (fs41.existsSync(prjctStatusLinePath)) {
-      const existingContent = fs41.readFileSync(prjctStatusLinePath, "utf8");
+    if (fs42.existsSync(prjctStatusLinePath)) {
+      const existingContent = fs42.readFileSync(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -21717,7 +22261,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          fs41.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+          fs42.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         installStatusLineModules(sourceLibDir, prjctLibDir);
         installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -21726,22 +22270,22 @@ async function installStatusLine() {
         return;
       }
     }
-    if (fs41.existsSync(sourceScript)) {
-      let scriptContent = fs41.readFileSync(sourceScript, "utf8");
+    if (fs42.existsSync(sourceScript)) {
+      let scriptContent = fs42.readFileSync(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      fs41.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs42.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
       installStatusLineModules(sourceLibDir, prjctLibDir);
       installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (fs41.existsSync(sourceThemeDir)) {
-        const themes = fs41.readdirSync(sourceThemeDir);
+      if (fs42.existsSync(sourceThemeDir)) {
+        const themes = fs42.readdirSync(sourceThemeDir);
         for (const theme of themes) {
-          const src = path44.join(sourceThemeDir, theme);
-          const dest = path44.join(prjctThemesDir, theme);
-          fs41.copyFileSync(src, dest);
+          const src = path45.join(sourceThemeDir, theme);
+          const dest = path45.join(prjctThemesDir, theme);
+          fs42.copyFileSync(src, dest);
         }
       }
-      if (!fs41.existsSync(prjctConfigPath) && fs41.existsSync(sourceConfigPath)) {
-        fs41.copyFileSync(sourceConfigPath, prjctConfigPath);
+      if (!fs42.existsSync(prjctConfigPath) && fs42.existsSync(sourceConfigPath)) {
+        fs42.copyFileSync(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -21776,7 +22320,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      fs41.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs42.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -21788,10 +22332,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path44.join(os13.homedir(), ".claude");
-    const mcpConfigPath = path44.join(claudeDir, "mcp.json");
-    if (!fs41.existsSync(claudeDir)) {
-      fs41.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = path45.join(os13.homedir(), ".claude");
+    const mcpConfigPath = path45.join(claudeDir, "mcp.json");
+    if (!fs42.existsSync(claudeDir)) {
+      fs42.mkdirSync(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -21801,54 +22345,54 @@ async function installContext7MCP() {
         }
       }
     };
-    if (fs41.existsSync(mcpConfigPath)) {
-      const existingContent = fs41.readFileSync(mcpConfigPath, "utf-8");
+    if (fs42.existsSync(mcpConfigPath)) {
+      const existingContent = fs42.readFileSync(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      fs41.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      fs42.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      fs41.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      fs42.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     console.error(`Context7 MCP setup warning: ${error.message}`);
   }
 }
 function installStatusLineModules(sourceDir, destDir) {
-  if (!fs41.existsSync(sourceDir)) {
+  if (!fs42.existsSync(sourceDir)) {
     return;
   }
-  const files = fs41.readdirSync(sourceDir);
+  const files = fs42.readdirSync(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path44.join(sourceDir, file);
-      const dest = path44.join(destDir, file);
-      fs41.copyFileSync(src, dest);
-      fs41.chmodSync(dest, 493);
+      const src = path45.join(sourceDir, file);
+      const dest = path45.join(destDir, file);
+      fs42.copyFileSync(src, dest);
+      fs42.chmodSync(dest, 493);
     }
   }
 }
 function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
-    if (fs41.existsSync(linkPath)) {
-      const stats = fs41.lstatSync(linkPath);
+    if (fs42.existsSync(linkPath)) {
+      const stats = fs42.lstatSync(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = fs41.readlinkSync(linkPath);
+        const existingTarget = fs42.readlinkSync(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      fs41.unlinkSync(linkPath);
+      fs42.unlinkSync(linkPath);
     }
-    fs41.symlinkSync(targetPath, linkPath);
+    fs42.symlinkSync(targetPath, linkPath);
   } catch (_error) {
     try {
-      if (fs41.existsSync(targetPath)) {
-        fs41.copyFileSync(targetPath, linkPath);
-        fs41.chmodSync(linkPath, 493);
+      if (fs42.existsSync(targetPath)) {
+        fs42.copyFileSync(targetPath, linkPath);
+        fs42.chmodSync(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -22263,7 +22807,7 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path45 from "node:path";
+import path46 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -22288,7 +22832,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path45.basename(projectPath);
+          const projectName = path46.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -22533,8 +23077,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs42 from "node:fs/promises";
-import path46 from "node:path";
+import fs43 from "node:fs/promises";
+import path47 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -22660,8 +23204,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path46.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs42.readFile(analysisPath, "utf-8");
+          const analysisPath = path47.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs43.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -22680,7 +23224,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path47 from "node:path";
+import path48 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -22696,7 +23240,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path47.basename(filePath));
+          results.rotated.push(path48.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -22803,7 +23347,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path48 from "node:path";
+import path49 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -22815,7 +23359,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 = path48.join(
+    const designsPath = path49.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -22855,7 +23399,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path48.join(designsPath, designFileName);
+    const designFilePath = path49.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -22879,7 +23423,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path49 from "node:path";
+import path50 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -22931,7 +23475,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path49.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path50.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync7 } = await import("node:child_process");
     try {
@@ -22949,7 +23493,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path49.join(snapshotsPath, "history.json");
+      const snapshotFile = path50.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -22989,8 +23533,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path49.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path49.join(snapshotsPath, "history.json");
+    const snapshotsPath = path50.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path50.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -23049,8 +23593,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path49.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path49.join(snapshotsPath, "history.json");
+    const snapshotsPath = path50.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path50.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -23157,8 +23701,8 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import fs43 from "node:fs";
-import path50 from "node:path";
+import fs44 from "node:fs";
+import path51 from "node:path";
 import chalk11 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -23285,7 +23829,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path50.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path51.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -23343,11 +23887,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs43.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs44.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs43.existsSync(settingsPath)) {
+          if (fs44.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs43.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs44.readFileSync(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -23355,7 +23899,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs43.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs44.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -23411,18 +23955,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path51 from "node:path";
+import path52 from "node:path";
 async function detectPackageManager(projectPath, pkg) {
   const declared = pkg?.packageManager?.trim().toLowerCase();
   if (declared?.startsWith("pnpm@")) return "pnpm";
   if (declared?.startsWith("yarn@")) return "yarn";
   if (declared?.startsWith("bun@")) return "bun";
   if (declared?.startsWith("npm@")) return "npm";
-  if (await fileExists(path51.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path51.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists(path51.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists(path51.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists(path51.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(path52.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path52.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path52.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path52.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path52.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -23438,7 +23982,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path51.join(projectPath, "package.json");
+  const pkgPath = path52.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -23455,27 +23999,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path51.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path52.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path51.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path52.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path51.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path52.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path51.join(projectPath, "go.mod"))) {
+  if (await fileExists(path52.join(projectPath, "go.mod"))) {
     return { stack: "go", test: { tool: "go", command: "go test ./..." } };
   }
   const files = await listFiles(projectPath);
   if (files.some((f) => f.endsWith(".sln") || f.endsWith(".csproj") || f.endsWith(".fsproj"))) {
     return { stack: "dotnet", test: { tool: "dotnet", command: "dotnet test" } };
   }
-  if (await fileExists(path51.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path52.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path51.join(projectPath, "gradlew")) && (await fileExists(path51.join(projectPath, "build.gradle")) || await fileExists(path51.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path52.join(projectPath, "gradlew")) && (await fileExists(path52.join(projectPath, "build.gradle")) || await fileExists(path52.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -23652,7 +24196,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path52 from "node:path";
+import path53 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -23798,7 +24342,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path52.join(projectPath, "package.json");
+          const pkgPath = path53.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);
@@ -23820,7 +24364,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path52.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path53.join(projectPath, "CHANGELOG.md");
           const changelog = await file_helper_exports.readFile(changelogPath, "# Changelog\n\n");
           const entry = `## [${version}] - ${date_helper_default.formatDate(/* @__PURE__ */ new Date())}
 
@@ -24712,19 +25256,19 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs44 from "node:fs";
+import fs45 from "node:fs";
 import os14 from "node:os";
-import path53 from "node:path";
+import path54 from "node:path";
 function getCredentialsPath(projectId) {
-  return path53.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path54.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
-  if (!fs44.existsSync(credPath)) {
+  if (!fs45.existsSync(credPath)) {
     return {};
   }
   try {
-    return JSON.parse(fs44.readFileSync(credPath, "utf-8"));
+    return JSON.parse(fs45.readFileSync(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", error.message);
     return {};
@@ -25297,7 +25841,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.56.1",
+      version: "0.58.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -25404,9 +25948,9 @@ var require_package = __commonJS({
 
 // core/index.ts
 var core_exports = {};
-import fs45 from "node:fs";
+import fs46 from "node:fs";
 import os15 from "node:os";
-import path54 from "node:path";
+import path55 from "node:path";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
   if (["-v", "--version", "version"].includes(commandName)) {
@@ -25487,7 +26031,8 @@ Use 'prjct --help' to see available commands.`);
           aiTools: options.agents ? String(options.agents).split(",") : void 0,
           preview: options.preview === true,
           yes: options.yes === true,
-          json: options.json === true
+          json: options.json === true,
+          package: options.package ? String(options.package) : void 0
         }), "sync"),
         start: /* @__PURE__ */ __name(() => commands.start(), "start"),
         // Context (for Claude templates)
@@ -25534,12 +26079,12 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 function displayVersion(version) {
   const detection = detectAllProviders();
-  const claudeCommandPath = path54.join(os15.homedir(), ".claude", "commands", "p.md");
-  const geminiCommandPath = path54.join(os15.homedir(), ".gemini", "commands", "p.toml");
-  const claudeConfigured = fs45.existsSync(claudeCommandPath);
-  const geminiConfigured = fs45.existsSync(geminiCommandPath);
-  const cursorConfigured = fs45.existsSync(path54.join(process.cwd(), ".cursor", "commands", "sync.md"));
-  const cursorExists = fs45.existsSync(path54.join(process.cwd(), ".cursor"));
+  const claudeCommandPath = path55.join(os15.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path55.join(os15.homedir(), ".gemini", "commands", "p.toml");
+  const claudeConfigured = fs46.existsSync(claudeCommandPath);
+  const geminiConfigured = fs46.existsSync(geminiCommandPath);
+  const cursorConfigured = fs46.existsSync(path55.join(process.cwd(), ".cursor", "commands", "sync.md"));
+  const cursorExists = fs46.existsSync(path55.join(process.cwd(), ".cursor"));
   console.log(`
 ${CYAN3}p/${RESET5} prjct v${version}
 ${DIM6}Context layer for AI coding agents${RESET5}
@@ -25672,9 +26217,9 @@ var init_core = __esm({
 init_ai_provider();
 init_config_manager();
 init_editors_config();
-import fs46 from "node:fs";
+import fs47 from "node:fs";
 import os16 from "node:os";
-import path55 from "node:path";
+import path56 from "node:path";
 
 // core/server/server.ts
 import { Hono as Hono3 } from "hono";
@@ -26416,14 +26961,14 @@ function checkRoutersInstalled() {
   const home = os16.homedir();
   const detection = detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path55.join(home, ".claude", "commands", "p.md");
-    if (!fs46.existsSync(claudeRouter)) {
+    const claudeRouter = path56.join(home, ".claude", "commands", "p.md");
+    if (!fs47.existsSync(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path55.join(home, ".gemini", "commands", "p.toml");
-    if (!fs46.existsSync(geminiRouter)) {
+    const geminiRouter = path56.join(home, ".gemini", "commands", "p.toml");
+    if (!fs47.existsSync(geminiRouter)) {
       return false;
     }
   }
@@ -26524,7 +27069,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path55.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path56.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -26543,12 +27088,12 @@ if (args[0] === "start" || args[0] === "setup") {
   const detection = detectAllProviders();
   const home = os16.homedir();
   const cwd = process.cwd();
-  const claudeConfigured = fs46.existsSync(path55.join(home, ".claude", "commands", "p.md"));
-  const geminiConfigured = fs46.existsSync(path55.join(home, ".gemini", "commands", "p.toml"));
-  const cursorDetected = fs46.existsSync(path55.join(cwd, ".cursor"));
-  const cursorConfigured = fs46.existsSync(path55.join(cwd, ".cursor", "rules", "prjct.mdc"));
-  const windsurfDetected = fs46.existsSync(path55.join(cwd, ".windsurf"));
-  const windsurfConfigured = fs46.existsSync(path55.join(cwd, ".windsurf", "rules", "prjct.md"));
+  const claudeConfigured = fs47.existsSync(path56.join(home, ".claude", "commands", "p.md"));
+  const geminiConfigured = fs47.existsSync(path56.join(home, ".gemini", "commands", "p.toml"));
+  const cursorDetected = fs47.existsSync(path56.join(cwd, ".cursor"));
+  const cursorConfigured = fs47.existsSync(path56.join(cwd, ".cursor", "rules", "prjct.mdc"));
+  const windsurfDetected = fs47.existsSync(path56.join(cwd, ".windsurf"));
+  const windsurfConfigured = fs47.existsSync(path56.join(cwd, ".windsurf", "rules", "prjct.md"));
   const GREEN7 = "\x1B[32m";
   console.log(`
 ${CYAN4}p/${RESET6} prjct v${VERSION}
@@ -26587,9 +27132,9 @@ ${DIM7}Run 'prjct init' to configure (Cursor/Windsurf IDE)${RESET6}
 ${CYAN4}https://prjct.app${RESET6}
 `);
 } else {
-  const configPath = path55.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path56.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = checkRoutersInstalled();
-  if (!fs46.existsSync(configPath) || !routersInstalled) {
+  if (!fs47.existsSync(configPath) || !routersInstalled) {
     console.log(`
 ${CYAN4}${BOLD4}  Welcome to prjct!${RESET6}