prjct-cli 0.58.0 → 0.60.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) => (path57) => {
-  var fn = map[path57];
+var __glob = (map) => (path58) => {
+  var fn = map[path58];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path57);
+  throw new Error("Module not found in bundle: " + path58);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -4019,8 +4019,8 @@ function tryResolve(basePath, projectPath) {
   for (const ext of extensions) {
     const fullPath = basePath + ext;
     try {
-      const fs48 = __require("node:fs");
-      if (fs48.existsSync(fullPath) && fs48.statSync(fullPath).isFile()) {
+      const fs49 = __require("node:fs");
+      if (fs49.existsSync(fullPath) && fs49.statSync(fullPath).isFile()) {
         return path12.relative(projectPath, fullPath);
       }
     } catch {
@@ -5203,11 +5203,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs48 = await import("node:fs/promises");
-  const path57 = await import("node:path");
-  const fullPath = path57.isAbsolute(filePath) ? filePath : path57.join(projectPath, filePath);
+  const fs49 = await import("node:fs/promises");
+  const path58 = await import("node:path");
+  const fullPath = path58.isAbsolute(filePath) ? filePath : path58.join(projectPath, filePath);
   try {
-    const stat = await fs48.stat(fullPath);
+    const stat = await fs49.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5274,11 +5274,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs48 = await import("node:fs/promises");
-  const path57 = await import("node:path");
-  const fullPath = path57.isAbsolute(targetPath) ? targetPath : path57.join(projectPath, targetPath);
+  const fs49 = await import("node:fs/promises");
+  const path58 = await import("node:path");
+  const fullPath = path58.isAbsolute(targetPath) ? targetPath : path58.join(projectPath, targetPath);
   try {
-    const stat = await fs48.stat(fullPath);
+    const stat = await fs49.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -8251,8 +8251,13 @@ var init_project = __esm({
       commitCount: z7.number(),
       createdAt: z7.string(),
       // ISO8601
-      lastSync: z7.string()
+      lastSync: z7.string(),
       // ISO8601
+      // Staleness tracking (PRJ-120)
+      lastSyncCommit: z7.string().optional(),
+      // Git commit hash at last sync
+      lastSyncBranch: z7.string().optional()
+      // Git branch at last sync
     });
     DEFAULT_PROJECT = {
       techStack: [],
@@ -15953,6 +15958,321 @@ ${content}`);
         }
         return results;
       }
+      // ==========================================================================
+      // AGENTS.md DISCOVERY AND RESOLUTION
+      // ==========================================================================
+      /**
+       * Discover all AGENTS.md files in the project/monorepo
+       */
+      async discoverAgentFiles() {
+        const agentFiles = [];
+        const rootAgentsPath = path33.join(this.rootPath, "AGENTS.md");
+        if (await fileExists(rootAgentsPath)) {
+          const rootAgents = await this.loadAgents(rootAgentsPath, null);
+          agentFiles.push(rootAgents);
+        }
+        if (this.monoInfo?.isMonorepo) {
+          for (const pkg of this.monoInfo.packages) {
+            const pkgAgentsPath = path33.join(pkg.path, "AGENTS.md");
+            if (await fileExists(pkgAgentsPath)) {
+              const parentAgents = agentFiles.find((a) => a.depth === 0) || null;
+              const pkgAgents = await this.loadAgents(pkgAgentsPath, parentAgents, pkg);
+              agentFiles.push(pkgAgents);
+              if (parentAgents) {
+                parentAgents.children.push(pkgAgents);
+              }
+            }
+          }
+        }
+        const additionalAgents = await this.scanForNestedAgents(this.rootPath, agentFiles);
+        agentFiles.push(...additionalAgents);
+        return agentFiles;
+      }
+      /**
+       * Load a single AGENTS.md file into a NestedAgents structure
+       */
+      async loadAgents(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,
+          agents: this.parseAgents(content),
+          package: pkg
+        };
+      }
+      /**
+       * Parse AGENTS.md content into agent definitions
+       *
+       * Expected format:
+       * ## AgentName @override?
+       *
+       * Description text here.
+       *
+       * ### Triggers
+       * - trigger phrase 1
+       * - trigger phrase 2
+       *
+       * ### Rules
+       * - rule 1
+       * - rule 2
+       *
+       * ### Patterns
+       * ```typescript
+       * // code pattern
+       * ```
+       */
+      parseAgents(content) {
+        const agents = [];
+        const lines = content.split("\n");
+        let currentAgent = null;
+        let currentSubsection = null;
+        let currentContent = [];
+        const saveCurrentContent = /* @__PURE__ */ __name(() => {
+          if (!currentAgent) return;
+          if (currentSubsection) {
+            const contentStr = currentContent.join("\n").trim();
+            switch (currentSubsection.toLowerCase()) {
+              case "triggers":
+                currentAgent.triggers = this.parseListItems(contentStr);
+                break;
+              case "rules":
+                currentAgent.rules = this.parseListItems(contentStr);
+                break;
+              case "patterns":
+                currentAgent.patterns = this.parseCodeBlocks(contentStr);
+                break;
+              case "examples":
+                currentAgent.examples = this.parseListItems(contentStr);
+                break;
+              case "domain":
+                currentAgent.domain = contentStr;
+                break;
+            }
+          } else {
+            const desc = currentContent.join("\n").trim();
+            if (desc && !currentAgent.description) {
+              currentAgent.description = desc;
+            }
+          }
+          currentContent = [];
+        }, "saveCurrentContent");
+        for (const line of lines) {
+          const agentMatch = line.match(/^##\s+([^#].+)$/);
+          if (agentMatch) {
+            if (currentAgent) {
+              saveCurrentContent();
+              agents.push(currentAgent);
+            }
+            const agentName = agentMatch[1];
+            const override = agentName.includes("@override") || agentName.includes("(override)");
+            currentAgent = {
+              name: agentName.replace(/@override|\(override\)/gi, "").trim(),
+              description: "",
+              override
+            };
+            currentSubsection = null;
+            currentContent = [];
+            continue;
+          }
+          const subsectionMatch = line.match(/^###\s+(.+)$/);
+          if (subsectionMatch && currentAgent) {
+            saveCurrentContent();
+            currentSubsection = subsectionMatch[1].trim();
+            currentContent = [];
+            continue;
+          }
+          if (currentAgent) {
+            currentContent.push(line);
+          }
+        }
+        if (currentAgent) {
+          saveCurrentContent();
+          agents.push(currentAgent);
+        }
+        return agents;
+      }
+      /**
+       * Parse list items from content (lines starting with - or *)
+       */
+      parseListItems(content) {
+        return content.split("\n").filter((line) => line.match(/^\s*[-*]\s+/)).map((line) => line.replace(/^\s*[-*]\s+/, "").trim()).filter((item) => item.length > 0);
+      }
+      /**
+       * Parse code blocks from content
+       */
+      parseCodeBlocks(content) {
+        const blocks = [];
+        const codeBlockRegex = /```[\w]*\n([\s\S]*?)```/g;
+        let match;
+        while ((match = codeBlockRegex.exec(content)) !== null) {
+          blocks.push(match[1].trim());
+        }
+        if (blocks.length === 0 && content.trim()) {
+          blocks.push(content.trim());
+        }
+        return blocks;
+      }
+      /**
+       * Scan for additional nested AGENTS.md files not in packages
+       */
+      async scanForNestedAgents(dir, existing) {
+        const found = [];
+        const existingPaths = new Set(existing.map((a) => a.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 agentsPath = path33.join(subDir, "AGENTS.md");
+                if (await fileExists(agentsPath) && !existingPaths.has(agentsPath)) {
+                  const parent = this.findParentAgents(agentsPath, existing.concat(found));
+                  const agents = await this.loadAgents(agentsPath, parent);
+                  found.push(agents);
+                  existingPaths.add(agentsPath);
+                  if (parent) {
+                    parent.children.push(agents);
+                  }
+                }
+                await scan(subDir, depth + 1);
+              }
+            }
+          } catch {
+          }
+        }, "scan");
+        await scan(dir, 0);
+        return found;
+      }
+      /**
+       * Find the parent agents file for a given path
+       */
+      findParentAgents(filePath, agentFiles) {
+        const fileDir = path33.dirname(filePath);
+        const sorted = [...agentFiles].sort((a, b) => b.depth - a.depth);
+        for (const agents of sorted) {
+          const agentsDir = path33.dirname(agents.path);
+          if (fileDir.startsWith(agentsDir) && fileDir !== agentsDir) {
+            return agents;
+          }
+        }
+        return null;
+      }
+      /**
+       * Resolve agents for a specific path by merging parent agent definitions
+       * Deeper files take precedence (can override parent agents)
+       */
+      async resolveAgentsForPath(targetPath) {
+        const agentFiles = await this.discoverAgentFiles();
+        const targetDir = path33.resolve(targetPath);
+        let bestMatch = null;
+        for (const agents of agentFiles) {
+          const agentsDir = path33.dirname(agents.path);
+          if (targetDir.startsWith(agentsDir)) {
+            if (!bestMatch || agents.depth > bestMatch.depth) {
+              bestMatch = agents;
+            }
+          }
+        }
+        if (!bestMatch) {
+          return {
+            agents: [],
+            sources: [],
+            overrides: []
+          };
+        }
+        const chain = [];
+        let current = bestMatch;
+        while (current) {
+          chain.unshift(current);
+          current = current.parent;
+        }
+        return this.mergeAgentsChain(chain);
+      }
+      /**
+       * Merge a chain of agent files following inheritance rules
+       */
+      mergeAgentsChain(chain) {
+        const mergedAgents = /* @__PURE__ */ new Map();
+        const sources = [];
+        const overrides = [];
+        for (const agentFile of chain) {
+          sources.push(agentFile.relativePath);
+          for (const agent of agentFile.agents) {
+            const existing = mergedAgents.get(agent.name);
+            if (agent.override || !existing) {
+              mergedAgents.set(agent.name, { ...agent });
+              if (agent.override && existing) {
+                overrides.push(`${agentFile.relativePath}:${agent.name}`);
+              }
+            } else {
+              const merged = { ...existing };
+              if (agent.triggers) {
+                merged.triggers = [...existing.triggers || [], ...agent.triggers];
+              }
+              if (agent.rules) {
+                merged.rules = [...existing.rules || [], ...agent.rules];
+              }
+              if (agent.patterns) {
+                merged.patterns = [...existing.patterns || [], ...agent.patterns];
+              }
+              if (agent.examples) {
+                merged.examples = [...existing.examples || [], ...agent.examples];
+              }
+              if (agent.description) {
+                merged.description = `${existing.description}
+
+${agent.description}`;
+              }
+              if (agent.domain) {
+                merged.domain = agent.domain;
+              }
+              mergedAgents.set(agent.name, merged);
+            }
+          }
+        }
+        return {
+          agents: Array.from(mergedAgents.values()),
+          sources,
+          overrides
+        };
+      }
+      /**
+       * Get agents for a specific monorepo package
+       */
+      async getPackageAgents(packageName) {
+        if (!this.monoInfo?.isMonorepo) {
+          return null;
+        }
+        const pkg = this.monoInfo.packages.find((p) => p.name === packageName);
+        if (!pkg) {
+          return null;
+        }
+        return this.resolveAgentsForPath(pkg.path);
+      }
+      /**
+       * Get all package agents in the monorepo
+       */
+      async getAllPackageAgents() {
+        const results = /* @__PURE__ */ new Map();
+        if (!this.monoInfo?.isMonorepo) {
+          return results;
+        }
+        for (const pkg of this.monoInfo.packages) {
+          const agents = await this.resolveAgentsForPath(pkg.path);
+          results.set(pkg.name, agents);
+        }
+        return results;
+      }
     };
   }
 });
@@ -16440,16 +16760,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs48 = await import("node:fs/promises");
-        const path57 = await import("node:path");
+        const fs49 = await import("node:fs/promises");
+        const path58 = await import("node:path");
         try {
-          const files = await fs48.readdir(this.projectPath);
+          const files = await fs49.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 = path57.join(this.projectPath, "package.json");
-            const pkgContent = await fs48.readFile(pkgPath, "utf-8");
+            const pkgPath = path58.join(this.projectPath, "package.json");
+            const pkgContent = await fs49.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -16485,32 +16805,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs48 = await import("node:fs/promises");
-        const path57 = await import("node:path");
+        const fs49 = await import("node:fs/promises");
+        const path58 = await import("node:path");
         const os17 = await import("node:os");
         const agents = [];
         try {
-          await fs48.access(path57.join(os17.homedir(), ".claude"));
+          await fs49.access(path58.join(os17.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs48.access(path57.join(this.projectPath, ".cursorrules"));
+          await fs49.access(path58.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs48.access(path57.join(this.projectPath, ".windsurfrules"));
+          await fs49.access(path58.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs48.access(path57.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs49.access(path58.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs48.access(path57.join(os17.homedir(), ".gemini"));
+          await fs49.access(path58.join(os17.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -16520,17 +16840,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs48 = await import("node:fs/promises");
-        const path57 = await import("node:path");
+        const fs49 = await import("node:fs/promises");
+        const path58 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs48.readdir(this.projectPath);
+          const files = await fs49.readdir(this.projectPath);
           if (files.includes("package.json")) {
-            const pkgPath = path57.join(this.projectPath, "package.json");
-            const pkgContent = await fs48.readFile(pkgPath, "utf-8");
+            const pkgPath = path58.join(this.projectPath, "package.json");
+            const pkgContent = await fs49.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -17992,6 +18312,52 @@ ${formatFullDiff(diff)}`);
           return { success: false, error: error.message };
         }
       }
+      /**
+       * /p:status - Check if CLAUDE.md context is stale
+       *
+       * Uses git commit history to detect when significant changes
+       * have occurred since the last sync.
+       *
+       * @see PRJ-120
+       */
+      async status(projectPath = process.cwd(), options = {}) {
+        try {
+          const initResult = await this.ensureProjectInit(projectPath);
+          if (!initResult.success) return initResult;
+          const projectId = await config_manager_default.getProjectId(projectPath);
+          if (!projectId) {
+            if (options.json) {
+              console.log(JSON.stringify({ success: false, error: "No project ID found" }));
+            } else {
+              output_default.fail("No project ID found");
+            }
+            return { success: false, error: "No project ID found" };
+          }
+          const checker = createStalenessChecker(projectPath);
+          const status = await checker.check(projectId);
+          if (options.json) {
+            console.log(
+              JSON.stringify({
+                success: true,
+                ...status
+              })
+            );
+            return { success: true, data: status };
+          }
+          console.log("");
+          console.log(checker.formatStatus(status));
+          console.log("");
+          return { success: true, data: status };
+        } catch (error) {
+          const errMsg = error.message;
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: errMsg }));
+          } else {
+            output_default.fail(errMsg);
+          }
+          return { success: false, error: errMsg };
+        }
+      }
       /**
        * Get session activity stats from today's events
        * @see PRJ-89
@@ -18599,8 +18965,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path37.join(globalPath2, "planning", "specs");
             try {
-              const fs48 = await import("node:fs/promises");
-              const files = await fs48.readdir(specsPath2);
+              const fs49 = await import("node:fs/promises");
+              const files = await fs49.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -18812,6 +19178,198 @@ var init_project_service = __esm({
   }
 });
 
+// core/services/staleness-checker.ts
+import { exec as exec10 } from "node:child_process";
+import fs36 from "node:fs/promises";
+import path38 from "node:path";
+import { promisify as promisify10 } from "node:util";
+var execAsync5, DEFAULT_CONFIG, StalenessChecker, createStalenessChecker;
+var init_staleness_checker = __esm({
+  "core/services/staleness-checker.ts"() {
+    "use strict";
+    init_path_manager();
+    execAsync5 = promisify10(exec10);
+    DEFAULT_CONFIG = {
+      commitThreshold: 10,
+      dayThreshold: 3,
+      significantFiles: [
+        "package.json",
+        "tsconfig.json",
+        "Cargo.toml",
+        "go.mod",
+        "requirements.txt",
+        "pyproject.toml",
+        ".env.example",
+        "docker-compose.yml",
+        "Dockerfile"
+      ]
+    };
+    StalenessChecker = class {
+      static {
+        __name(this, "StalenessChecker");
+      }
+      projectPath;
+      config;
+      constructor(projectPath, config = {}) {
+        this.projectPath = projectPath;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+      }
+      /**
+       * Check if the project context is stale
+       */
+      async check(projectId) {
+        const status = {
+          isStale: false,
+          reason: null,
+          lastSyncCommit: null,
+          currentCommit: null,
+          commitsSinceSync: 0,
+          daysSinceSync: 0,
+          changedFiles: [],
+          significantChanges: []
+        };
+        try {
+          const projectJsonPath = path38.join(path_manager_default.getGlobalProjectPath(projectId), "project.json");
+          let projectJson = {};
+          try {
+            projectJson = JSON.parse(await fs36.readFile(projectJsonPath, "utf-8"));
+          } catch {
+            status.isStale = true;
+            status.reason = "No sync history found. Run `prjct sync` to initialize.";
+            return status;
+          }
+          status.lastSyncCommit = projectJson.lastSyncCommit || null;
+          const lastSync = projectJson.lastSync;
+          try {
+            const { stdout } = await execAsync5("git rev-parse --short HEAD", {
+              cwd: this.projectPath
+            });
+            status.currentCommit = stdout.trim();
+          } catch {
+            status.reason = "Not a git repository";
+            return status;
+          }
+          if (!status.lastSyncCommit) {
+            status.isStale = true;
+            status.reason = "No sync commit recorded. Run `prjct sync` to track.";
+            return status;
+          }
+          if (status.lastSyncCommit === status.currentCommit) {
+            status.reason = "Context is up to date";
+            return status;
+          }
+          try {
+            const { stdout } = await execAsync5(`git rev-list --count ${status.lastSyncCommit}..HEAD`, {
+              cwd: this.projectPath
+            });
+            status.commitsSinceSync = parseInt(stdout.trim(), 10) || 0;
+          } catch {
+            status.isStale = true;
+            status.reason = "Sync commit no longer exists (history changed). Run `prjct sync`.";
+            return status;
+          }
+          if (lastSync) {
+            const syncDate = new Date(lastSync);
+            const now = /* @__PURE__ */ new Date();
+            status.daysSinceSync = Math.floor(
+              (now.getTime() - syncDate.getTime()) / (1e3 * 60 * 60 * 24)
+            );
+          }
+          try {
+            const { stdout } = await execAsync5(`git diff --name-only ${status.lastSyncCommit}..HEAD`, {
+              cwd: this.projectPath
+            });
+            status.changedFiles = stdout.trim().split("\n").filter(Boolean);
+          } catch {
+            status.changedFiles = [];
+          }
+          status.significantChanges = status.changedFiles.filter(
+            (file) => this.config.significantFiles.some((sig) => file.endsWith(sig) || file.includes(sig))
+          );
+          if (status.commitsSinceSync >= this.config.commitThreshold) {
+            status.isStale = true;
+            status.reason = `${status.commitsSinceSync} commits since last sync (threshold: ${this.config.commitThreshold})`;
+          } else if (status.daysSinceSync >= this.config.dayThreshold) {
+            status.isStale = true;
+            status.reason = `${status.daysSinceSync} days since last sync (threshold: ${this.config.dayThreshold})`;
+          } else if (status.significantChanges.length > 0) {
+            status.isStale = true;
+            status.reason = `Significant files changed: ${status.significantChanges.join(", ")}`;
+          } else if (status.commitsSinceSync > 0) {
+            status.reason = `${status.commitsSinceSync} commits since sync (threshold: ${this.config.commitThreshold})`;
+          } else {
+            status.reason = "Context is up to date";
+          }
+          return status;
+        } catch (error) {
+          status.reason = `Error checking staleness: ${error.message}`;
+          return status;
+        }
+      }
+      /**
+       * Format staleness status for display
+       */
+      formatStatus(status) {
+        const lines = [];
+        if (status.isStale) {
+          lines.push("CLAUDE.md status: \u26A0\uFE0F  STALE");
+        } else {
+          lines.push("CLAUDE.md status: \u2713 Fresh");
+        }
+        lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+        if (status.lastSyncCommit) {
+          lines.push(`Last sync:      ${status.lastSyncCommit}`);
+        }
+        if (status.currentCommit) {
+          lines.push(`Current:        ${status.currentCommit}`);
+        }
+        if (status.commitsSinceSync > 0) {
+          lines.push(`Commits since:  ${status.commitsSinceSync}`);
+        }
+        if (status.daysSinceSync > 0) {
+          lines.push(`Days since:     ${status.daysSinceSync}`);
+        }
+        if (status.changedFiles.length > 0) {
+          lines.push(`Files changed:  ${status.changedFiles.length}`);
+        }
+        if (status.significantChanges.length > 0) {
+          lines.push(``);
+          lines.push(`Significant changes:`);
+          for (const file of status.significantChanges.slice(0, 5)) {
+            lines.push(`  \u2022 ${file}`);
+          }
+          if (status.significantChanges.length > 5) {
+            lines.push(`  ... and ${status.significantChanges.length - 5} more`);
+          }
+        }
+        if (status.reason) {
+          lines.push(``);
+          lines.push(status.reason);
+        }
+        if (status.isStale) {
+          lines.push(``);
+          lines.push(`Run \`prjct sync\` to update context`);
+        }
+        return lines.join("\n");
+      }
+      /**
+       * Get a short warning message if stale (for other commands)
+       */
+      getWarning(status) {
+        if (!status.isStale) return null;
+        if (status.commitsSinceSync > 0) {
+          return `\u26A0\uFE0F  Context stale (${status.commitsSinceSync} commits behind). Run \`prjct sync\``;
+        }
+        if (status.daysSinceSync > 0) {
+          return `\u26A0\uFE0F  Context stale (${status.daysSinceSync} days old). Run \`prjct sync\``;
+        }
+        return `\u26A0\uFE0F  Context may be stale. Run \`prjct sync\``;
+      }
+    };
+    createStalenessChecker = /* @__PURE__ */ __name((projectPath, config) => new StalenessChecker(projectPath, config), "createStalenessChecker");
+  }
+});
+
 // core/ai-tools/formatters.ts
 function formatForClaude(ctx, _config) {
   return `# ${ctx.name} - Project Rules
@@ -19031,9 +19589,9 @@ var init_formatters = __esm({
 
 // core/ai-tools/registry.ts
 import { execSync as execSync4 } from "node:child_process";
-import fs36 from "node:fs";
+import fs37 from "node:fs";
 import os11 from "node:os";
-import path38 from "node:path";
+import path39 from "node:path";
 function getAIToolConfig(id) {
   return AI_TOOLS[id] || null;
 }
@@ -19050,16 +19608,16 @@ function detectInstalledTools(repoPath = process.cwd()) {
   if (commandExists("claude")) {
     detected.push("claude");
   }
-  if (commandExists("cursor") || fs36.existsSync(path38.join(repoPath, ".cursor"))) {
+  if (commandExists("cursor") || fs37.existsSync(path39.join(repoPath, ".cursor"))) {
     detected.push("cursor");
   }
-  if (fs36.existsSync(path38.join(repoPath, ".github"))) {
+  if (fs37.existsSync(path39.join(repoPath, ".github"))) {
     detected.push("copilot");
   }
-  if (commandExists("windsurf") || fs36.existsSync(path38.join(repoPath, ".windsurf"))) {
+  if (commandExists("windsurf") || fs37.existsSync(path39.join(repoPath, ".windsurf"))) {
     detected.push("windsurf");
   }
-  if (fs36.existsSync(path38.join(repoPath, ".continue")) || fs36.existsSync(path38.join(os11.homedir(), ".continue"))) {
+  if (fs37.existsSync(path39.join(repoPath, ".continue")) || fs37.existsSync(path39.join(os11.homedir(), ".continue"))) {
     detected.push("continue");
   }
   return detected;
@@ -19135,8 +19693,8 @@ var init_registry = __esm({
 });
 
 // core/ai-tools/generator.ts
-import fs37 from "node:fs/promises";
-import path39 from "node:path";
+import fs38 from "node:fs/promises";
+import path40 from "node:path";
 async function generateAIToolContexts(context2, globalPath, repoPath, toolIds = DEFAULT_AI_TOOLS) {
   const results = [];
   for (const toolId of toolIds) {
@@ -19171,13 +19729,13 @@ async function generateForTool(context2, config, globalPath, repoPath) {
     let content = formatter(context2, config);
     let outputPath;
     if (config.outputPath === "repo") {
-      outputPath = path39.join(repoPath, config.outputFile);
+      outputPath = path40.join(repoPath, config.outputFile);
     } else {
-      outputPath = path39.join(globalPath, "context", config.outputFile);
+      outputPath = path40.join(globalPath, "context", config.outputFile);
     }
-    await fs37.mkdir(path39.dirname(outputPath), { recursive: true });
+    await fs38.mkdir(path40.dirname(outputPath), { recursive: true });
     try {
-      const existingContent = await fs37.readFile(outputPath, "utf-8");
+      const existingContent = await fs38.readFile(outputPath, "utf-8");
       const validation = validatePreserveBlocks(existingContent);
       if (!validation.valid) {
         console.warn(`\u26A0\uFE0F  ${config.outputFile} has invalid preserve blocks:`);
@@ -19188,7 +19746,7 @@ async function generateForTool(context2, config, globalPath, repoPath) {
       content = mergePreservedSections(content, existingContent);
     } catch {
     }
-    await fs37.writeFile(outputPath, content, "utf-8");
+    await fs38.writeFile(outputPath, content, "utf-8");
     return {
       toolId: config.id,
       outputFile: config.outputFile,
@@ -19227,8 +19785,8 @@ var init_ai_tools = __esm({
 });
 
 // core/services/context-generator.ts
-import fs38 from "node:fs/promises";
-import path40 from "node:path";
+import fs39 from "node:fs/promises";
+import path41 from "node:path";
 var ContextFileGenerator;
 var init_context_generator = __esm({
   "core/services/context-generator.ts"() {
@@ -19252,10 +19810,10 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs38.readFile(filePath, "utf-8");
+          const existingContent = await fs39.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
-            const filename = path40.basename(filePath);
+            const filename = path41.basename(filePath);
             console.warn(`\u26A0\uFE0F  ${filename} has invalid preserve blocks:`);
             for (const error of validation.errors) {
               console.warn(`   ${error}`);
@@ -19264,13 +19822,13 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs38.writeFile(filePath, finalContent, "utf-8");
+        await fs39.writeFile(filePath, finalContent, "utf-8");
       }
       /**
        * Generate all context files in parallel
        */
       async generate(git, stats, commands, agents) {
-        const contextPath = path40.join(this.config.globalPath, "context");
+        const contextPath = path41.join(this.config.globalPath, "context");
         await Promise.all([
           this.generateClaudeMd(contextPath, git, stats, commands, agents),
           this.generateNowMd(contextPath),
@@ -19364,7 +19922,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 **Workflow**: ${workflowAgents.join(", ")}
 **Domain**: ${domainAgents.join(", ") || "none"}
 `;
-        const claudePath = path40.join(contextPath, "CLAUDE.md");
+        const claudePath = path41.join(contextPath, "CLAUDE.md");
         await this.writeWithPreservation(claudePath, content);
       }
       /**
@@ -19373,8 +19931,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
       async generateNowMd(contextPath) {
         let currentTask = null;
         try {
-          const statePath = path40.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs38.readFile(statePath, "utf-8"));
+          const statePath = path41.join(this.config.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs39.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -19390,7 +19948,7 @@ _No active task_
 
 Use \`p. task "description"\` to start working.
 `;
-        await this.writeWithPreservation(path40.join(contextPath, "now.md"), content);
+        await this.writeWithPreservation(path41.join(contextPath, "now.md"), content);
       }
       /**
        * Generate next.md - task queue
@@ -19398,15 +19956,15 @@ Use \`p. task "description"\` to start working.
       async generateNextMd(contextPath) {
         let queue = { tasks: [] };
         try {
-          const queuePath = path40.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs38.readFile(queuePath, "utf-8"));
+          const queuePath = path41.join(this.config.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs39.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(path40.join(contextPath, "next.md"), content);
+        await this.writeWithPreservation(path41.join(contextPath, "next.md"), content);
       }
       /**
        * Generate ideas.md - captured ideas
@@ -19414,15 +19972,15 @@ ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}
       async generateIdeasMd(contextPath) {
         let ideas = { ideas: [] };
         try {
-          const ideasPath = path40.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs38.readFile(ideasPath, "utf-8"));
+          const ideasPath = path41.join(this.config.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs39.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(path40.join(contextPath, "ideas.md"), content);
+        await this.writeWithPreservation(path41.join(contextPath, "ideas.md"), content);
       }
       /**
        * Generate shipped.md - completed features
@@ -19432,8 +19990,8 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
           shipped: []
         };
         try {
-          const shippedPath = path40.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs38.readFile(shippedPath, "utf-8"));
+          const shippedPath = path41.join(this.config.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs39.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -19442,7 +20000,7 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
 
 **Total shipped:** ${shipped.shipped.length}
 `;
-        await this.writeWithPreservation(path40.join(contextPath, "shipped.md"), content);
+        await this.writeWithPreservation(path41.join(contextPath, "shipped.md"), content);
       }
       // ==========================================================================
       // MONOREPO SUPPORT
@@ -19471,9 +20029,9 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
             commands,
             agents
           );
-          const claudePath = path40.join(pkg.path, "CLAUDE.md");
+          const claudePath = path41.join(pkg.path, "CLAUDE.md");
           await this.writeWithPreservation(claudePath, content);
-          generatedFiles.push(path40.relative(this.config.projectPath, claudePath));
+          generatedFiles.push(path41.relative(this.config.projectPath, claudePath));
         }
         return generatedFiles;
       }
@@ -19486,8 +20044,8 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
         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"));
+          const pkgJsonPath = path41.join(pkg.path, "package.json");
+          const pkgJson = JSON.parse(await fs39.readFile(pkgJsonPath, "utf-8"));
           pkgVersion = pkgJson.version || stats.version;
           pkgName = pkgJson.name || pkg.name;
         } catch {
@@ -19552,8 +20110,8 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 });
 
 // core/services/stack-detector.ts
-import fs39 from "node:fs/promises";
-import path41 from "node:path";
+import fs40 from "node:fs/promises";
+import path42 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
   "core/services/stack-detector.ts"() {
@@ -19712,8 +20270,8 @@ var init_stack_detector = __esm({
        */
       async readPackageJson() {
         try {
-          const pkgPath = path41.join(this.projectPath, "package.json");
-          const content = await fs39.readFile(pkgPath, "utf-8");
+          const pkgPath = path42.join(this.projectPath, "package.json");
+          const content = await fs40.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -19724,7 +20282,7 @@ var init_stack_detector = __esm({
        */
       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;
@@ -19735,11 +20293,11 @@ var init_stack_detector = __esm({
 });
 
 // core/services/sync-service.ts
-import { exec as exec10 } from "node:child_process";
-import fs40 from "node:fs/promises";
-import path42 from "node:path";
-import { promisify as promisify10 } from "node:util";
-var execAsync5, SyncService, syncService;
+import { exec as exec11 } from "node:child_process";
+import fs41 from "node:fs/promises";
+import path43 from "node:path";
+import { promisify as promisify11 } from "node:util";
+var execAsync6, SyncService, syncService;
 var init_sync_service = __esm({
   "core/services/sync-service.ts"() {
     "use strict";
@@ -19751,7 +20309,7 @@ var init_sync_service = __esm({
     init_date_helper();
     init_context_generator();
     init_stack_detector();
-    execAsync5 = promisify10(exec10);
+    execAsync6 = promisify11(exec11);
     SyncService = class {
       static {
         __name(this, "SyncService");
@@ -19886,7 +20444,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs40.mkdir(path42.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs41.mkdir(path43.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -19905,19 +20463,19 @@ var init_sync_service = __esm({
           weeklyCommits: 0
         };
         try {
-          const { stdout: branch } = await execAsync5("git branch --show-current", {
+          const { stdout: branch } = await execAsync6("git branch --show-current", {
             cwd: this.projectPath
           });
           data.branch = branch.trim() || "main";
-          const { stdout: commits } = await execAsync5("git rev-list --count HEAD", {
+          const { stdout: commits } = await execAsync6("git rev-list --count HEAD", {
             cwd: this.projectPath
           });
           data.commits = parseInt(commits.trim(), 10) || 0;
-          const { stdout: contributors } = await execAsync5("git shortlog -sn --all | wc -l", {
+          const { stdout: contributors } = await execAsync6("git shortlog -sn --all | wc -l", {
             cwd: this.projectPath
           });
           data.contributors = parseInt(contributors.trim(), 10) || 0;
-          const { stdout: status } = await execAsync5("git status --porcelain", {
+          const { stdout: status } = await execAsync6("git status --porcelain", {
             cwd: this.projectPath
           });
           const lines = status.trim().split("\n").filter(Boolean);
@@ -19933,7 +20491,7 @@ var init_sync_service = __esm({
               data.untrackedFiles.push(file);
             }
           }
-          const { stdout: log } = await execAsync5(
+          const { stdout: log } = await execAsync6(
             'git log --oneline -20 --pretty=format:"%h|%s|%ad" --date=short',
             { cwd: this.projectPath }
           );
@@ -19941,7 +20499,7 @@ var init_sync_service = __esm({
             const [hash, message, date] = line.split("|");
             return { hash, message, date };
           });
-          const { stdout: weekly } = await execAsync5('git log --oneline --since="1 week ago" | wc -l', {
+          const { stdout: weekly } = await execAsync6('git log --oneline --since="1 week ago" | wc -l', {
             cwd: this.projectPath
           });
           data.weeklyCommits = parseInt(weekly.trim(), 10) || 0;
@@ -19956,14 +20514,14 @@ var init_sync_service = __esm({
         const stats = {
           fileCount: 0,
           version: "0.0.0",
-          name: path42.basename(this.projectPath),
+          name: path43.basename(this.projectPath),
           ecosystem: "unknown",
           projectType: "simple",
           languages: [],
           frameworks: []
         };
         try {
-          const { stdout } = await execAsync5(
+          const { stdout } = await execAsync6(
             'find . -type f \\( -name "*.js" -o -name "*.ts" -o -name "*.tsx" -o -name "*.py" -o -name "*.go" -o -name "*.rs" \\) -not -path "./node_modules/*" -not -path "./.git/*" | wc -l',
             { cwd: this.projectPath }
           );
@@ -19972,8 +20530,8 @@ var init_sync_service = __esm({
           stats.fileCount = 0;
         }
         try {
-          const pkgPath = path42.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs40.readFile(pkgPath, "utf-8"));
+          const pkgPath = path43.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs41.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -20081,12 +20639,12 @@ var init_sync_service = __esm({
       // ==========================================================================
       async generateAgents(stack, stats) {
         const agents = [];
-        const agentsPath = path42.join(this.globalPath, "agents");
+        const agentsPath = path43.join(this.globalPath, "agents");
         try {
-          const files = await fs40.readdir(agentsPath);
+          const files = await fs41.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs40.unlink(path42.join(agentsPath, file));
+              await fs41.unlink(path43.join(agentsPath, file));
             }
           }
         } catch {
@@ -20126,7 +20684,7 @@ var init_sync_service = __esm({
       async generateWorkflowAgent(name, agentsPath) {
         let content = "";
         try {
-          const templatePath = path42.join(
+          const templatePath = path43.join(
             __dirname,
             "..",
             "..",
@@ -20135,16 +20693,16 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs40.readFile(templatePath, "utf-8");
+          content = await fs41.readFile(templatePath, "utf-8");
         } catch {
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs40.writeFile(path42.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs41.writeFile(path43.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
         try {
-          const templatePath = path42.join(
+          const templatePath = path43.join(
             __dirname,
             "..",
             "..",
@@ -20153,14 +20711,14 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs40.readFile(templatePath, "utf-8");
+          content = await fs41.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 fs40.writeFile(path42.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs41.writeFile(path43.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -20228,8 +20786,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]))
         };
-        fs40.writeFile(
-          path42.join(this.globalPath, "config", "skills.json"),
+        fs41.writeFile(
+          path43.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
         ).catch(() => {
@@ -20251,10 +20809,10 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // PROJECT.JSON UPDATE
       // ==========================================================================
       async updateProjectJson(git, stats) {
-        const projectJsonPath = path42.join(this.globalPath, "project.json");
+        const projectJsonPath = path43.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs40.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs41.readFile(projectJsonPath, "utf-8"));
         } catch {
         }
         const updated = {
@@ -20271,18 +20829,21 @@ You are the ${name} expert for this project. Apply best practices for the detect
           currentBranch: git.branch,
           hasUncommittedChanges: git.hasChanges,
           createdAt: existing.createdAt || date_helper_default.getTimestamp(),
-          lastSync: date_helper_default.getTimestamp()
+          lastSync: date_helper_default.getTimestamp(),
+          // Staleness tracking (PRJ-120)
+          lastSyncCommit: git.recentCommits[0]?.hash || null,
+          lastSyncBranch: git.branch
         };
-        await fs40.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs41.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
       // ==========================================================================
       async updateStateJson(stats, stack) {
-        const statePath = path42.join(this.globalPath, "storage", "state.json");
+        const statePath = path43.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs40.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs41.readFile(statePath, "utf-8"));
         } catch {
         }
         state.projectId = this.projectId;
@@ -20309,13 +20870,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 fs40.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs41.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
       }
       // ==========================================================================
       // MEMORY LOGGING
       // ==========================================================================
       async logToMemory(git, stats) {
-        const memoryPath = path42.join(this.globalPath, "memory", "events.jsonl");
+        const memoryPath = path43.join(this.globalPath, "memory", "events.jsonl");
         const event = {
           ts: date_helper_default.getTimestamp(),
           action: "sync",
@@ -20324,7 +20885,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs40.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs41.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -20344,16 +20905,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 = path42.join(this.globalPath, file);
-            const content = await fs40.readFile(filePath, "utf-8");
+            const filePath = path43.join(this.globalPath, file);
+            const content = await fs41.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
         }
         for (const agent of agents) {
           try {
-            const agentPath = path42.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs40.readFile(agentPath, "utf-8");
+            const agentPath = path43.join(this.globalPath, "agents", `${agent.name}.md`);
+            const content = await fs41.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch {
           }
@@ -20385,7 +20946,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs40.access(path42.join(this.projectPath, filename));
+          await fs41.access(path43.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -20393,8 +20954,8 @@ You are the ${name} expert for this project. Apply best practices for the detect
       }
       async getCliVersion() {
         try {
-          const pkgPath = path42.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs40.readFile(pkgPath, "utf-8"));
+          const pkgPath = path43.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs41.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch {
           return "0.0.0";
@@ -20467,6 +21028,7 @@ var init_services = __esm({
     init_nested_context_resolver();
     init_project_index();
     init_project_service();
+    init_staleness_checker();
     init_sync_service();
   }
 });
@@ -20554,22 +21116,22 @@ __export(uninstall_exports, {
 });
 import { execSync as execSync5 } from "node:child_process";
 import fsSync2 from "node:fs";
-import fs41 from "node:fs/promises";
+import fs42 from "node:fs/promises";
 import os12 from "node:os";
-import path43 from "node:path";
+import path44 from "node:path";
 import readline2 from "node:readline";
 import chalk9 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs41.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs42.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path43.join(dirPath, entry.name);
+      const entryPath = path44.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs41.stat(entryPath);
+          const stats = await fs42.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -20588,7 +21150,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs41.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs42.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -20621,7 +21183,7 @@ async function gatherUninstallItems() {
   const providerPaths = getProviderPaths();
   const prjctCliPath = path_manager_default.getGlobalBasePath();
   const prjctCliExists = fsSync2.existsSync(prjctCliPath);
-  const projectCount = prjctCliExists ? await countDirectoryItems(path43.join(prjctCliPath, "projects")) : 0;
+  const projectCount = prjctCliExists ? await countDirectoryItems(path44.join(prjctCliPath, "projects")) : 0;
   const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0;
   items.push({
     path: prjctCliPath,
@@ -20631,7 +21193,7 @@ async function gatherUninstallItems() {
     count: projectCount,
     exists: prjctCliExists
   });
-  const claudeMdPath = path43.join(providerPaths.claude.config, "CLAUDE.md");
+  const claudeMdPath = path44.join(providerPaths.claude.config, "CLAUDE.md");
   const claudeMdExists = fsSync2.existsSync(claudeMdPath);
   let hasPrjctSection = false;
   if (claudeMdExists) {
@@ -20665,7 +21227,7 @@ async function gatherUninstallItems() {
     description: "Claude router",
     exists: claudeRouterExists
   });
-  const statusLinePath = path43.join(providerPaths.claude.config, "prjct-statusline.sh");
+  const statusLinePath = path44.join(providerPaths.claude.config, "prjct-statusline.sh");
   const statusLineExists = fsSync2.existsSync(statusLinePath);
   items.push({
     path: statusLinePath,
@@ -20681,7 +21243,7 @@ async function gatherUninstallItems() {
     description: "Gemini router",
     exists: geminiRouterExists
   });
-  const geminiMdPath = path43.join(providerPaths.gemini.config, "GEMINI.md");
+  const geminiMdPath = path44.join(providerPaths.gemini.config, "GEMINI.md");
   const geminiMdExists = fsSync2.existsSync(geminiMdPath);
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
@@ -20703,7 +21265,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs41.readFile(filePath, "utf-8");
+    const content = await fs42.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -20712,9 +21274,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 fs41.unlink(filePath);
+      await fs42.unlink(filePath);
     } else {
-      await fs41.writeFile(filePath, `${newContent}
+      await fs42.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -20725,12 +21287,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 = path43.join(homeDir, `.prjct-backup-${timestamp}`);
+  const backupDir = path44.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs41.mkdir(backupDir, { recursive: true });
+    await fs42.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (fsSync2.existsSync(prjctCliPath)) {
-      await copyDirectory(prjctCliPath, path43.join(backupDir, ".prjct-cli"));
+      await copyDirectory(prjctCliPath, path44.join(backupDir, ".prjct-cli"));
     }
     return backupDir;
   } catch {
@@ -20738,15 +21300,15 @@ async function createBackup() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs41.mkdir(dest, { recursive: true });
-  const entries = await fs41.readdir(src, { withFileTypes: true });
+  await fs42.mkdir(dest, { recursive: true });
+  const entries = await fs42.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path43.join(src, entry.name);
-    const destPath = path43.join(dest, entry.name);
+    const srcPath = path44.join(src, entry.name);
+    const destPath = path44.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs41.copyFile(srcPath, destPath);
+      await fs42.copyFile(srcPath, destPath);
     }
   }
 }
@@ -20762,10 +21324,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs41.rm(item.path, { recursive: true, force: true });
+        await fs42.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs41.unlink(item.path);
+        await fs42.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -20940,7 +21502,7 @@ __export(watch_service_exports, {
   WatchService: () => WatchService,
   watchService: () => watchService
 });
-import path44 from "node:path";
+import path45 from "node:path";
 import chalk10 from "chalk";
 import chokidar from "chokidar";
 var TRIGGER_PATTERNS, IGNORE_PATTERNS2, WatchService, watchService;
@@ -21145,7 +21707,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: ${path44.basename(this.projectPath)}`));
+        console.log(chalk10.dim(`   Project: ${path45.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("");
@@ -21337,6 +21899,22 @@ var init_command_data = __esm({
         hasTemplate: true,
         requiresProject: true
       },
+      {
+        name: "status",
+        group: "core",
+        description: "Check if CLAUDE.md context is stale and needs resync",
+        usage: { claude: "/p:status", terminal: "prjct status" },
+        params: "[--json]",
+        implemented: true,
+        hasTemplate: false,
+        requiresProject: true,
+        features: [
+          "Compares current HEAD with last sync commit",
+          "Counts commits and days since sync",
+          "Detects significant file changes",
+          "Configurable staleness thresholds"
+        ]
+      },
       {
         name: "help",
         group: "core",
@@ -21802,9 +22380,9 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync6 } from "node:child_process";
-import fs42 from "node:fs";
+import fs43 from "node:fs";
 import os13 from "node:os";
-import path45 from "node:path";
+import path46 from "node:path";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
   try {
@@ -21910,12 +22488,12 @@ async function run() {
 }
 async function installGeminiRouter() {
   try {
-    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);
+    const geminiCommandsDir = path46.join(os13.homedir(), ".gemini", "commands");
+    const routerSource = path46.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = path46.join(geminiCommandsDir, "p.toml");
+    fs43.mkdirSync(geminiCommandsDir, { recursive: true });
+    if (fs43.existsSync(routerSource)) {
+      fs43.copyFileSync(routerSource, routerDest);
       return true;
     }
     return false;
@@ -21926,15 +22504,15 @@ async function installGeminiRouter() {
 }
 async function installGeminiGlobalConfig() {
   try {
-    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");
+    const geminiDir = path46.join(os13.homedir(), ".gemini");
+    const globalConfigPath = path46.join(geminiDir, "GEMINI.md");
+    const templatePath = path46.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    fs43.mkdirSync(geminiDir, { recursive: true });
+    const templateContent = fs43.readFileSync(templatePath, "utf-8");
     let existingContent = "";
     let fileExists2 = false;
     try {
-      existingContent = fs42.readFileSync(globalConfigPath, "utf-8");
+      existingContent = fs43.readFileSync(globalConfigPath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -21944,7 +22522,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!fileExists2) {
-      fs42.writeFileSync(globalConfigPath, templateContent, "utf-8");
+      fs43.writeFileSync(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -21954,7 +22532,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      fs42.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
+      fs43.writeFileSync(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -21966,7 +22544,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    fs42.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    fs43.writeFileSync(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     console.error(`Gemini config warning: ${error.message}`);
@@ -21975,18 +22553,18 @@ ${templateContent}`;
 }
 async function installAntigravitySkill() {
   try {
-    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)) {
+    const antigravitySkillsDir = path46.join(os13.homedir(), ".gemini", "antigravity", "skills");
+    const prjctSkillDir = path46.join(antigravitySkillsDir, "prjct");
+    const skillMdPath = path46.join(prjctSkillDir, "SKILL.md");
+    const templatePath = path46.join(getPackageRoot(), "templates", "antigravity", "SKILL.md");
+    fs43.mkdirSync(prjctSkillDir, { recursive: true });
+    const fileExists2 = fs43.existsSync(skillMdPath);
+    if (!fs43.existsSync(templatePath)) {
       console.error("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = fs42.readFileSync(templatePath, "utf-8");
-    fs42.writeFileSync(skillMdPath, templateContent, "utf-8");
+    const templateContent = fs43.readFileSync(templatePath, "utf-8");
+    fs43.writeFileSync(skillMdPath, templateContent, "utf-8");
     return { success: true, action: fileExists2 ? "updated" : "created" };
   } catch (error) {
     console.error(`Antigravity skill warning: ${error.message}`);
@@ -22005,24 +22583,24 @@ async function installCursorProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    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);
+    const cursorDir = path46.join(projectRoot, ".cursor");
+    const rulesDir = path46.join(cursorDir, "rules");
+    const commandsDir = path46.join(cursorDir, "commands");
+    const routerMdcDest = path46.join(rulesDir, "prjct.mdc");
+    const routerMdcSource = path46.join(getPackageRoot(), "templates", "cursor", "router.mdc");
+    const cursorCommandsSource = path46.join(getPackageRoot(), "templates", "cursor", "commands");
+    fs43.mkdirSync(rulesDir, { recursive: true });
+    fs43.mkdirSync(commandsDir, { recursive: true });
+    if (fs43.existsSync(routerMdcSource)) {
+      fs43.copyFileSync(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
-    if (fs42.existsSync(cursorCommandsSource)) {
-      const commandFiles = fs42.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
+    if (fs43.existsSync(cursorCommandsSource)) {
+      const commandFiles = fs43.readdirSync(cursorCommandsSource).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
-        const src = path45.join(cursorCommandsSource, file);
-        const dest = path45.join(commandsDir, file);
-        fs42.copyFileSync(src, dest);
+        const src = path46.join(cursorCommandsSource, file);
+        const dest = path46.join(commandsDir, file);
+        fs43.copyFileSync(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -22036,7 +22614,7 @@ async function installCursorProject(projectRoot) {
 }
 async function addCursorToGitignore(projectRoot) {
   try {
-    const gitignorePath = path45.join(projectRoot, ".gitignore");
+    const gitignorePath = path46.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Cursor routers (regenerated per-developer)",
       ".cursor/rules/prjct.mdc",
@@ -22051,7 +22629,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs42.readFileSync(gitignorePath, "utf-8");
+      content = fs43.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -22066,7 +22644,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs42.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs43.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -22074,12 +22652,12 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasCursorProject(projectRoot) {
-  return fs42.existsSync(path45.join(projectRoot, ".cursor"));
+  return fs43.existsSync(path46.join(projectRoot, ".cursor"));
 }
 function needsCursorRegeneration(projectRoot) {
-  const cursorDir = path45.join(projectRoot, ".cursor");
-  const routerPath = path45.join(cursorDir, "rules", "prjct.mdc");
-  return fs42.existsSync(cursorDir) && !fs42.existsSync(routerPath);
+  const cursorDir = path46.join(projectRoot, ".cursor");
+  const routerPath = path46.join(cursorDir, "rules", "prjct.mdc");
+  return fs43.existsSync(cursorDir) && !fs43.existsSync(routerPath);
 }
 async function installWindsurfProject(projectRoot) {
   const result = {
@@ -22089,29 +22667,29 @@ async function installWindsurfProject(projectRoot) {
     gitignoreUpdated: false
   };
   try {
-    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(
+    const windsurfDir = path46.join(projectRoot, ".windsurf");
+    const rulesDir = path46.join(windsurfDir, "rules");
+    const workflowsDir = path46.join(windsurfDir, "workflows");
+    const routerDest = path46.join(rulesDir, "prjct.md");
+    const routerSource = path46.join(getPackageRoot(), "templates", "windsurf", "router.md");
+    const windsurfWorkflowsSource = path46.join(
       getPackageRoot(),
       "templates",
       "windsurf",
       "workflows"
     );
-    fs42.mkdirSync(rulesDir, { recursive: true });
-    fs42.mkdirSync(workflowsDir, { recursive: true });
-    if (fs42.existsSync(routerSource)) {
-      fs42.copyFileSync(routerSource, routerDest);
+    fs43.mkdirSync(rulesDir, { recursive: true });
+    fs43.mkdirSync(workflowsDir, { recursive: true });
+    if (fs43.existsSync(routerSource)) {
+      fs43.copyFileSync(routerSource, routerDest);
       result.rulesCreated = true;
     }
-    if (fs42.existsSync(windsurfWorkflowsSource)) {
-      const workflowFiles = fs42.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
+    if (fs43.existsSync(windsurfWorkflowsSource)) {
+      const workflowFiles = fs43.readdirSync(windsurfWorkflowsSource).filter((f) => f.endsWith(".md"));
       for (const file of workflowFiles) {
-        const src = path45.join(windsurfWorkflowsSource, file);
-        const dest = path45.join(workflowsDir, file);
-        fs42.copyFileSync(src, dest);
+        const src = path46.join(windsurfWorkflowsSource, file);
+        const dest = path46.join(workflowsDir, file);
+        fs43.copyFileSync(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -22125,7 +22703,7 @@ async function installWindsurfProject(projectRoot) {
 }
 async function addWindsurfToGitignore(projectRoot) {
   try {
-    const gitignorePath = path45.join(projectRoot, ".gitignore");
+    const gitignorePath = path46.join(projectRoot, ".gitignore");
     const entriesToAdd = [
       "# prjct Windsurf routers (regenerated per-developer)",
       ".windsurf/rules/prjct.md",
@@ -22140,7 +22718,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let fileExists2 = false;
     try {
-      content = fs42.readFileSync(gitignorePath, "utf-8");
+      content = fs43.readFileSync(gitignorePath, "utf-8");
       fileExists2 = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -22155,7 +22733,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    fs42.writeFileSync(gitignorePath, newContent, "utf-8");
+    fs43.writeFileSync(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     console.error(`Gitignore update warning: ${error.message}`);
@@ -22163,32 +22741,32 @@ ${entriesToAdd.join("\n")}
   }
 }
 function hasWindsurfProject(projectRoot) {
-  return fs42.existsSync(path45.join(projectRoot, ".windsurf"));
+  return fs43.existsSync(path46.join(projectRoot, ".windsurf"));
 }
 function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = path45.join(projectRoot, ".windsurf");
-  const routerPath = path45.join(windsurfDir, "rules", "prjct.md");
-  return fs42.existsSync(windsurfDir) && !fs42.existsSync(routerPath);
+  const windsurfDir = path46.join(projectRoot, ".windsurf");
+  const routerPath = path46.join(windsurfDir, "rules", "prjct.md");
+  return fs43.existsSync(windsurfDir) && !fs43.existsSync(routerPath);
 }
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = path45.join(os13.homedir(), ".prjct-cli", "projects");
-    if (!fs42.existsSync(projectsDir)) {
+    const projectsDir = path46.join(os13.homedir(), ".prjct-cli", "projects");
+    if (!fs43.existsSync(projectsDir)) {
       return;
     }
-    const projectDirs = fs42.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = fs43.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = path45.join(projectsDir, projectId, "project.json");
-      if (!fs42.existsSync(projectJsonPath)) {
+      const projectJsonPath = path46.join(projectsDir, projectId, "project.json");
+      if (!fs43.existsSync(projectJsonPath)) {
         continue;
       }
       try {
-        const content = fs42.readFileSync(projectJsonPath, "utf8");
+        const content = fs43.readFileSync(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          fs42.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          fs43.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -22208,9 +22786,9 @@ async function migrateProjectsCliVersion() {
 }
 function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
-  if (fs42.existsSync(settingsPath)) {
+  if (fs43.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs42.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(fs43.readFileSync(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -22218,42 +22796,42 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  fs42.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  fs43.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
-    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 });
+    const claudeDir = path46.join(os13.homedir(), ".claude");
+    const settingsPath = path46.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = path46.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = path46.join(os13.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = path46.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = path46.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = path46.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = path46.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = path46.join(prjctStatusLineDir, "config.json");
+    const assetsDir = path46.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = path46.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = path46.join(assetsDir, "themes");
+    const sourceLibDir = path46.join(assetsDir, "lib");
+    const sourceComponentsDir = path46.join(assetsDir, "components");
+    const sourceConfigPath = path46.join(assetsDir, "default-config.json");
+    if (!fs43.existsSync(claudeDir)) {
+      fs43.mkdirSync(claudeDir, { recursive: true });
     }
-    if (!fs42.existsSync(prjctStatusLineDir)) {
-      fs42.mkdirSync(prjctStatusLineDir, { recursive: true });
+    if (!fs43.existsSync(prjctStatusLineDir)) {
+      fs43.mkdirSync(prjctStatusLineDir, { recursive: true });
     }
-    if (!fs42.existsSync(prjctThemesDir)) {
-      fs42.mkdirSync(prjctThemesDir, { recursive: true });
+    if (!fs43.existsSync(prjctThemesDir)) {
+      fs43.mkdirSync(prjctThemesDir, { recursive: true });
     }
-    if (!fs42.existsSync(prjctLibDir)) {
-      fs42.mkdirSync(prjctLibDir, { recursive: true });
+    if (!fs43.existsSync(prjctLibDir)) {
+      fs43.mkdirSync(prjctLibDir, { recursive: true });
     }
-    if (!fs42.existsSync(prjctComponentsDir)) {
-      fs42.mkdirSync(prjctComponentsDir, { recursive: true });
+    if (!fs43.existsSync(prjctComponentsDir)) {
+      fs43.mkdirSync(prjctComponentsDir, { recursive: true });
     }
-    if (fs42.existsSync(prjctStatusLinePath)) {
-      const existingContent = fs42.readFileSync(prjctStatusLinePath, "utf8");
+    if (fs43.existsSync(prjctStatusLinePath)) {
+      const existingContent = fs43.readFileSync(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -22261,7 +22839,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          fs42.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+          fs43.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         installStatusLineModules(sourceLibDir, prjctLibDir);
         installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -22270,22 +22848,22 @@ async function installStatusLine() {
         return;
       }
     }
-    if (fs42.existsSync(sourceScript)) {
-      let scriptContent = fs42.readFileSync(sourceScript, "utf8");
+    if (fs43.existsSync(sourceScript)) {
+      let scriptContent = fs43.readFileSync(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      fs42.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs43.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
       installStatusLineModules(sourceLibDir, prjctLibDir);
       installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (fs42.existsSync(sourceThemeDir)) {
-        const themes = fs42.readdirSync(sourceThemeDir);
+      if (fs43.existsSync(sourceThemeDir)) {
+        const themes = fs43.readdirSync(sourceThemeDir);
         for (const theme of themes) {
-          const src = path45.join(sourceThemeDir, theme);
-          const dest = path45.join(prjctThemesDir, theme);
-          fs42.copyFileSync(src, dest);
+          const src = path46.join(sourceThemeDir, theme);
+          const dest = path46.join(prjctThemesDir, theme);
+          fs43.copyFileSync(src, dest);
         }
       }
-      if (!fs42.existsSync(prjctConfigPath) && fs42.existsSync(sourceConfigPath)) {
-        fs42.copyFileSync(sourceConfigPath, prjctConfigPath);
+      if (!fs43.existsSync(prjctConfigPath) && fs43.existsSync(sourceConfigPath)) {
+        fs43.copyFileSync(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -22320,7 +22898,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      fs42.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      fs43.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -22332,10 +22910,10 @@ echo "prjct"
 }
 async function installContext7MCP() {
   try {
-    const claudeDir = path45.join(os13.homedir(), ".claude");
-    const mcpConfigPath = path45.join(claudeDir, "mcp.json");
-    if (!fs42.existsSync(claudeDir)) {
-      fs42.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = path46.join(os13.homedir(), ".claude");
+    const mcpConfigPath = path46.join(claudeDir, "mcp.json");
+    if (!fs43.existsSync(claudeDir)) {
+      fs43.mkdirSync(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -22345,54 +22923,54 @@ async function installContext7MCP() {
         }
       }
     };
-    if (fs42.existsSync(mcpConfigPath)) {
-      const existingContent = fs42.readFileSync(mcpConfigPath, "utf-8");
+    if (fs43.existsSync(mcpConfigPath)) {
+      const existingContent = fs43.readFileSync(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      fs42.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      fs43.writeFileSync(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      fs42.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      fs43.writeFileSync(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     console.error(`Context7 MCP setup warning: ${error.message}`);
   }
 }
 function installStatusLineModules(sourceDir, destDir) {
-  if (!fs42.existsSync(sourceDir)) {
+  if (!fs43.existsSync(sourceDir)) {
     return;
   }
-  const files = fs42.readdirSync(sourceDir);
+  const files = fs43.readdirSync(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = path45.join(sourceDir, file);
-      const dest = path45.join(destDir, file);
-      fs42.copyFileSync(src, dest);
-      fs42.chmodSync(dest, 493);
+      const src = path46.join(sourceDir, file);
+      const dest = path46.join(destDir, file);
+      fs43.copyFileSync(src, dest);
+      fs43.chmodSync(dest, 493);
     }
   }
 }
 function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
-    if (fs42.existsSync(linkPath)) {
-      const stats = fs42.lstatSync(linkPath);
+    if (fs43.existsSync(linkPath)) {
+      const stats = fs43.lstatSync(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = fs42.readlinkSync(linkPath);
+        const existingTarget = fs43.readlinkSync(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      fs42.unlinkSync(linkPath);
+      fs43.unlinkSync(linkPath);
     }
-    fs42.symlinkSync(targetPath, linkPath);
+    fs43.symlinkSync(targetPath, linkPath);
   } catch (_error) {
     try {
-      if (fs42.existsSync(targetPath)) {
-        fs42.copyFileSync(targetPath, linkPath);
-        fs42.chmodSync(linkPath, 493);
+      if (fs43.existsSync(targetPath)) {
+        fs43.copyFileSync(targetPath, linkPath);
+        fs43.chmodSync(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -22807,11 +23385,12 @@ var init_registry2 = __esm({
 });
 
 // core/commands/analytics.ts
-import path46 from "node:path";
+import path47 from "node:path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
     "use strict";
+    init_services();
     init_storage2();
     init_base();
     init_registry2();
@@ -22832,7 +23411,7 @@ var init_analytics = __esm({
             output_default.failWithHint("NO_PROJECT_ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path46.basename(projectPath);
+          const projectName = path47.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -22902,6 +23481,13 @@ var init_analytics = __esm({
 \u{1F4CA} DASHBOARD - ${projectName}
 `);
           console.log("\u2550".repeat(50));
+          const checker = createStalenessChecker(projectPath);
+          const stalenessStatus = await checker.check(projectId);
+          const stalenessWarning = checker.getWarning(stalenessStatus);
+          if (stalenessWarning) {
+            console.log(`
+${stalenessWarning}`);
+          }
           console.log("\n\u{1F3AF} CURRENT FOCUS");
           if (currentTask) {
             console.log(`   ${currentTask.description}`);
@@ -23077,8 +23663,8 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs43 from "node:fs/promises";
-import path47 from "node:path";
+import fs44 from "node:fs/promises";
+import path48 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
   "core/commands/context.ts"() {
@@ -23204,8 +23790,8 @@ var init_context = __esm({
        */
       async loadRepoAnalysis(globalPath) {
         try {
-          const analysisPath = path47.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs43.readFile(analysisPath, "utf-8");
+          const analysisPath = path48.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs44.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -23224,7 +23810,7 @@ var init_context = __esm({
 });
 
 // core/commands/cleanup.ts
-import path48 from "node:path";
+import path49 from "node:path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -23240,7 +23826,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path48.basename(filePath));
+          results.rotated.push(path49.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -23347,7 +23933,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path49 from "node:path";
+import path50 from "node:path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -23359,7 +23945,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 = path49.join(
+    const designsPath = path50.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -23399,7 +23985,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path49.join(designsPath, designFileName);
+    const designFilePath = path50.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -23423,7 +24009,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path50 from "node:path";
+import path51 from "node:path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -23475,7 +24061,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path50.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotsPath = path51.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
     await file_helper_exports.ensureDir(snapshotsPath);
     const { execSync: execSync7 } = await import("node:child_process");
     try {
@@ -23493,7 +24079,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path50.join(snapshotsPath, "history.json");
+      const snapshotFile = path51.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -23533,8 +24119,8 @@ async function redo(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path50.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path50.join(snapshotsPath, "history.json");
+    const snapshotsPath = path51.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path51.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -23593,8 +24179,8 @@ async function history(projectPath = process.cwd()) {
       output_default.failWithHint("NO_PROJECT_ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path50.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
-    const snapshotFile = path50.join(snapshotsPath, "history.json");
+    const snapshotsPath = path51.join(path_manager_default.getGlobalProjectPath(projectId), "snapshots");
+    const snapshotFile = path51.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -23701,8 +24287,8 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import fs44 from "node:fs";
-import path51 from "node:path";
+import fs45 from "node:fs";
+import path52 from "node:path";
 import chalk11 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -23829,7 +24415,7 @@ Please install it first:
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path51.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path52.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -23887,11 +24473,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs44.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs45.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs44.existsSync(settingsPath)) {
+          if (fs45.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs44.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs45.readFileSync(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -23899,7 +24485,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs44.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs45.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -23955,18 +24541,18 @@ echo "\u26A1 prjct"
 });
 
 // core/utils/project-commands.ts
-import path52 from "node:path";
+import path53 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(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";
+  if (await fileExists(path53.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path53.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path53.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path53.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path53.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -23982,7 +24568,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path52.join(projectPath, "package.json");
+  const pkgPath = path53.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -23999,27 +24585,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path52.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path53.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path52.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path53.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path52.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path53.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path52.join(projectPath, "go.mod"))) {
+  if (await fileExists(path53.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(path52.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path53.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path52.join(projectPath, "gradlew")) && (await fileExists(path52.join(projectPath, "build.gradle")) || await fileExists(path52.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path53.join(projectPath, "gradlew")) && (await fileExists(path53.join(projectPath, "build.gradle")) || await fileExists(path53.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -24036,8 +24622,8 @@ var init_project_commands = __esm({
 });
 
 // core/workflow/workflow-preferences.ts
-import { exec as exec11 } from "node:child_process";
-import { promisify as promisify11 } from "node:util";
+import { exec as exec12 } from "node:child_process";
+import { promisify as promisify12 } from "node:util";
 function prefKey(hook, command) {
   return `workflow:${hook}_${command}`;
 }
@@ -24108,7 +24694,7 @@ async function runWorkflowHooks(projectId, phase, command, options = {}) {
 ${DIM5}Running ${phase}-${command}: ${action}${RESET4}`);
   try {
     const startTime = Date.now();
-    await execAsync6(action, {
+    await execAsync7(action, {
       timeout: 6e4,
       cwd: options.projectPath || process.cwd(),
       env: { ...process.env }
@@ -24172,12 +24758,12 @@ Set one: "p. workflow antes de ship corre los tests"`;
   lines.push(`${DIM5}Remove: "p. workflow quita el hook de ship"${RESET4}`);
   return lines.join("\n");
 }
-var execAsync6, DIM5, GREEN5, RED, YELLOW5, RESET4, sessionPreferences, oncePreferences;
+var execAsync7, DIM5, GREEN5, RED, YELLOW5, RESET4, sessionPreferences, oncePreferences;
 var init_workflow_preferences = __esm({
   "core/workflow/workflow-preferences.ts"() {
     "use strict";
     init_memory_system();
-    execAsync6 = promisify11(exec11);
+    execAsync7 = promisify12(exec12);
     DIM5 = "\x1B[2m";
     GREEN5 = "\x1B[32m";
     RED = "\x1B[31m";
@@ -24196,7 +24782,7 @@ var init_workflow_preferences = __esm({
 });
 
 // core/commands/shipping.ts
-import path53 from "node:path";
+import path54 from "node:path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -24342,7 +24928,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path53.join(projectPath, "package.json");
+          const pkgPath = path54.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);
@@ -24364,7 +24950,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path53.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path54.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())}
 
@@ -24463,14 +25049,14 @@ var init_cache2 = __esm({
 });
 
 // core/utils/keychain.ts
-import { exec as exec12 } from "node:child_process";
-import { promisify as promisify12 } from "node:util";
+import { exec as exec13 } from "node:child_process";
+import { promisify as promisify13 } from "node:util";
 async function getCredential(key) {
   if (process.platform !== "darwin") {
     return getEnvFallback(key);
   }
   try {
-    const { stdout } = await execAsync7(
+    const { stdout } = await execAsync8(
       `security find-generic-password -s "${SERVICE_NAME}" -a "${key}" -w 2>/dev/null`
     );
     return stdout.trim() || null;
@@ -24486,11 +25072,11 @@ function getEnvFallback(key) {
   const envVar = envMap[key];
   return process.env[envVar] || null;
 }
-var execAsync7, SERVICE_NAME;
+var execAsync8, SERVICE_NAME;
 var init_keychain = __esm({
   "core/utils/keychain.ts"() {
     "use strict";
-    execAsync7 = promisify12(exec12);
+    execAsync8 = promisify13(exec13);
     SERVICE_NAME = "prjct-cli";
     __name(getCredential, "getCredential");
     __name(getEnvFallback, "getEnvFallback");
@@ -25256,19 +25842,19 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs45 from "node:fs";
+import fs46 from "node:fs";
 import os14 from "node:os";
-import path54 from "node:path";
+import path55 from "node:path";
 function getCredentialsPath(projectId) {
-  return path54.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
+  return path55.join(os14.homedir(), ".prjct-cli", "projects", projectId, "config", "credentials.json");
 }
 async function getProjectCredentials(projectId) {
   const credPath = getCredentialsPath(projectId);
-  if (!fs45.existsSync(credPath)) {
+  if (!fs46.existsSync(credPath)) {
     return {};
   }
   try {
-    return JSON.parse(fs45.readFileSync(credPath, "utf-8"));
+    return JSON.parse(fs46.readFileSync(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", error.message);
     return {};
@@ -25721,6 +26307,9 @@ var init_commands = __esm({
       async stats(projectPath = process.cwd(), options = {}) {
         return this.analysis.stats(projectPath, options);
       }
+      async status(projectPath = process.cwd(), options = {}) {
+        return this.analysis.status(projectPath, options);
+      }
       // ========== Context Commands ==========
       async context(input = null, projectPath = process.cwd()) {
         return this.contextCmds.context(input, projectPath);
@@ -25790,6 +26379,7 @@ function registerAllCommands() {
   commandRegistry.registerMethod("analyze", analysis, "analyze", getMeta("analyze"));
   commandRegistry.registerMethod("sync", analysis, "sync", getMeta("sync"));
   commandRegistry.registerMethod("stats", analysis, "stats", getMeta("stats"));
+  commandRegistry.registerMethod("status", analysis, "status", getMeta("status"));
   commandRegistry.registerMethod("start", setup, "start", getMeta("start"));
   commandRegistry.registerMethod("setup", setup, "setup", getMeta("setup"));
   commandRegistry.registerMethod("uninstall", uninstallCmd, "uninstall", getMeta("uninstall"));
@@ -25841,7 +26431,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.58.0",
+      version: "0.60.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -25948,9 +26538,9 @@ var require_package = __commonJS({
 
 // core/index.ts
 var core_exports = {};
-import fs46 from "node:fs";
+import fs47 from "node:fs";
 import os15 from "node:os";
-import path55 from "node:path";
+import path56 from "node:path";
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2);
   if (["-v", "--version", "version"].includes(commandName)) {
@@ -26020,6 +26610,9 @@ Use 'prjct --help' to see available commands.`);
           json: options.json === true,
           export: options.export === true
         }), "stats"),
+        status: /* @__PURE__ */ __name(() => commands.status(process.cwd(), {
+          json: options.json === true
+        }), "status"),
         help: /* @__PURE__ */ __name((p) => commands.help(p || ""), "help"),
         // Maintenance
         recover: /* @__PURE__ */ __name(() => commands.recover(), "recover"),
@@ -26079,12 +26672,12 @@ function parseCommandArgs(_cmd, rawArgs) {
 }
 function displayVersion(version) {
   const detection = detectAllProviders();
-  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"));
+  const claudeCommandPath = path56.join(os15.homedir(), ".claude", "commands", "p.md");
+  const geminiCommandPath = path56.join(os15.homedir(), ".gemini", "commands", "p.toml");
+  const claudeConfigured = fs47.existsSync(claudeCommandPath);
+  const geminiConfigured = fs47.existsSync(geminiCommandPath);
+  const cursorConfigured = fs47.existsSync(path56.join(process.cwd(), ".cursor", "commands", "sync.md"));
+  const cursorExists = fs47.existsSync(path56.join(process.cwd(), ".cursor"));
   console.log(`
 ${CYAN3}p/${RESET5} prjct v${version}
 ${DIM6}Context layer for AI coding agents${RESET5}
@@ -26217,9 +26810,9 @@ var init_core = __esm({
 init_ai_provider();
 init_config_manager();
 init_editors_config();
-import fs47 from "node:fs";
+import fs48 from "node:fs";
 import os16 from "node:os";
-import path56 from "node:path";
+import path57 from "node:path";
 
 // core/server/server.ts
 import { Hono as Hono3 } from "hono";
@@ -26961,14 +27554,14 @@ function checkRoutersInstalled() {
   const home = os16.homedir();
   const detection = detectAllProviders();
   if (detection.claude.installed) {
-    const claudeRouter = path56.join(home, ".claude", "commands", "p.md");
-    if (!fs47.existsSync(claudeRouter)) {
+    const claudeRouter = path57.join(home, ".claude", "commands", "p.md");
+    if (!fs48.existsSync(claudeRouter)) {
       return false;
     }
   }
   if (detection.gemini.installed) {
-    const geminiRouter = path56.join(home, ".gemini", "commands", "p.toml");
-    if (!fs47.existsSync(geminiRouter)) {
+    const geminiRouter = path57.join(home, ".gemini", "commands", "p.toml");
+    if (!fs48.existsSync(geminiRouter)) {
       return false;
     }
   }
@@ -27069,7 +27662,7 @@ if (args[0] === "start" || args[0] === "setup") {
     console.error('No prjct project found. Run "prjct init" first.');
     process.exitCode = 1;
   } else {
-    const linearCliPath = path56.join(__dirname, "..", "core", "cli", "linear.ts");
+    const linearCliPath = path57.join(__dirname, "..", "core", "cli", "linear.ts");
     const linearArgs = ["--project", projectId, ...args.slice(1)];
     const child = spawn("bun", [linearCliPath, ...linearArgs], {
       stdio: "inherit",
@@ -27088,12 +27681,12 @@ if (args[0] === "start" || args[0] === "setup") {
   const detection = detectAllProviders();
   const home = os16.homedir();
   const cwd = process.cwd();
-  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 claudeConfigured = fs48.existsSync(path57.join(home, ".claude", "commands", "p.md"));
+  const geminiConfigured = fs48.existsSync(path57.join(home, ".gemini", "commands", "p.toml"));
+  const cursorDetected = fs48.existsSync(path57.join(cwd, ".cursor"));
+  const cursorConfigured = fs48.existsSync(path57.join(cwd, ".cursor", "rules", "prjct.mdc"));
+  const windsurfDetected = fs48.existsSync(path57.join(cwd, ".windsurf"));
+  const windsurfConfigured = fs48.existsSync(path57.join(cwd, ".windsurf", "rules", "prjct.md"));
   const GREEN7 = "\x1B[32m";
   console.log(`
 ${CYAN4}p/${RESET6} prjct v${VERSION}
@@ -27132,9 +27725,9 @@ ${DIM7}Run 'prjct init' to configure (Cursor/Windsurf IDE)${RESET6}
 ${CYAN4}https://prjct.app${RESET6}
 `);
 } else {
-  const configPath = path56.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
+  const configPath = path57.join(os16.homedir(), ".prjct-cli", "config", "installed-editors.json");
   const routersInstalled = checkRoutersInstalled();
-  if (!fs47.existsSync(configPath) || !routersInstalled) {
+  if (!fs48.existsSync(configPath) || !routersInstalled) {
     console.log(`
 ${CYAN4}${BOLD4}  Welcome to prjct!${RESET6}