prjct-cli 0.35.3 → 0.35.4

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) => (path35) => {
-  var fn = map[path35];
+var __glob = (map) => (path37) => {
+  var fn = map[path37];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path35);
+  throw new Error("Module not found in bundle: " + path37);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -3201,10 +3201,10 @@ var init_context_builder = __esm({
        * Load current project state - PARALLEL VERSION
        * Uses Promise.all() for 40-60% faster file I/O
        */
-      async loadState(context, onlyKeys = null) {
+      async loadState(context2, onlyKeys = null) {
         this._clearCacheIfStale();
         const state = {};
-        const entries = Object.entries(context.paths);
+        const entries = Object.entries(context2.paths);
         const filteredEntries = onlyKeys ? entries.filter(([key]) => onlyKeys.includes(key)) : entries;
         for (const [, filePath] of filteredEntries) {
           if (this._cache.has(filePath)) {
@@ -3260,7 +3260,7 @@ var init_context_builder = __esm({
        * Load state for specific command - optimized selective loading
        * Each command only loads what it needs
        */
-      async loadStateForCommand(context, commandName) {
+      async loadStateForCommand(context2, commandName) {
         const commandFileMap = {
           // Core workflow
           now: ["now", "next", "analysis", "codePatterns"],
@@ -3289,7 +3289,7 @@ var init_context_builder = __esm({
           default: ["analysis", "codePatterns"]
         };
         const requiredFiles = commandFileMap[commandName] || commandFileMap.default;
-        return this.loadState(context, requiredFiles);
+        return this.loadState(context2, requiredFiles);
       }
       /**
        * Batch read multiple files in parallel
@@ -5540,8 +5540,8 @@ var init_prompt_builder = __esm({
       /**
        * Set context for testing
        */
-      setContext(context) {
-        this._currentContext = context;
+      setContext(context2) {
+        this._currentContext = context2;
       }
       /**
        * Load quality checklists from templates/checklists/
@@ -5681,17 +5681,17 @@ var init_prompt_builder = __esm({
        * Build a complete prompt with auto-injected context.
        * This is the preferred method - automatically includes state and insights.
        */
-      async buildWithInjection(template, context, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null) {
+      async buildWithInjection(template, context2, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null) {
         const parts = [];
-        if (context.projectId) {
-          const injected = await this.buildInjectedContext(context.projectId);
+        if (context2.projectId) {
+          const injected = await this.buildInjectedContext(context2.projectId);
           if (injected) {
             parts.push(injected);
           }
         }
         const basePrompt = this.build(
           template,
-          context,
+          context2,
           state,
           agent,
           learnedPatterns,
@@ -5706,9 +5706,9 @@ var init_prompt_builder = __esm({
        * Build a complete prompt for Claude from template, context, and enhancements
        * @deprecated Use buildWithInjection for auto-injected context
        */
-      build(template, context, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null, orchestratorContext = null) {
+      build(template, context2, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null, orchestratorContext = null) {
         const parts = [];
-        this._currentContext = context;
+        this._currentContext = context2;
         const commandName = template.frontmatter?.name?.replace("p:", "") || "";
         const agentCommands = ["now", "build", "feature", "design", "fix", "bug", "test", "work", "cleanup", "spec"];
         const needsAgent = agentCommands.includes(commandName);
@@ -5730,7 +5730,7 @@ Apply specialized expertise. Read agent file for details if needed.
           parts.push(`TOOLS: ${template.frontmatter["allowed-tools"].join(", ")}
 `);
         }
-        const params = context;
+        const params = context2;
         if (params.params?.task || params.params?.description) {
           parts.push(`INPUT: ${params.params.task || params.params.description}
 `);
@@ -5807,16 +5807,16 @@ ${truncatedContent}
           parts.push(relevantState);
           parts.push("\n");
         }
-        const files = context.files || [];
+        const files = context2.files || [];
         if (files.length > 0) {
           const top5 = files.slice(0, 5).join(", ");
           parts.push(`
 ## FILES: ${files.length} available. Top: ${top5}
 `);
           parts.push("Read BEFORE modifying. Use Glob/Grep to find more.\n\n");
-        } else if (context.projectPath) {
+        } else if (context2.projectPath) {
           parts.push(`
-## PROJECT: ${context.projectPath}
+## PROJECT: ${context2.projectPath}
 Read files before modifying.
 
 `);
@@ -5937,7 +5937,7 @@ ${content.substring(0, 500)}... (truncated, use Read tool for full content)`
       /**
        * Build an analysis prompt for pre-action investigation tasks
        */
-      buildAnalysis(analysisType, context) {
+      buildAnalysis(analysisType, context2) {
         const parts = [];
         parts.push(`# Analyze: ${analysisType}
 
@@ -5945,9 +5945,9 @@ ${content.substring(0, 500)}... (truncated, use Read tool for full content)`
         parts.push("Read the project context and provide your analysis.\n");
         parts.push("No predetermined patterns - decide based on what you find.\n\n");
         parts.push("## Project Context\n");
-        parts.push(`- Path: ${context.projectPath}
+        parts.push(`- Path: ${context2.projectPath}
 `);
-        parts.push(`- ID: ${context.projectId}
+        parts.push(`- ID: ${context2.projectId}
 
 `);
         return parts.join("");
@@ -6211,20 +6211,20 @@ var init_loop_detector = __esm({
       /**
        * Generate a unique key for tracking attempts
        */
-      _getKey(command, context = "") {
-        return `${command}:${context}`.toLowerCase();
+      _getKey(command, context2 = "") {
+        return `${command}:${context2}`.toLowerCase();
       }
       /**
        * Record an attempt for a command
        */
-      recordAttempt(command, context = "", result = {}) {
-        const key = this._getKey(command, context);
+      recordAttempt(command, context2 = "", result = {}) {
+        const key = this._getKey(command, context2);
         const now = Date.now();
         let record = this._attempts.get(key);
         if (!record || now - record.lastAttempt > this.sessionTimeout) {
           record = {
             command,
-            context,
+            context: context2,
             attempts: 0,
             errors: [],
             firstAttempt: now,
@@ -6244,15 +6244,15 @@ var init_loop_detector = __esm({
         this._attempts.set(key, record);
         return {
           attemptNumber: record.attempts,
-          isLooping: this.isLooping(command, context),
-          shouldEscalate: this.shouldEscalate(command, context)
+          isLooping: this.isLooping(command, context2),
+          shouldEscalate: this.shouldEscalate(command, context2)
         };
       }
       /**
        * Check if a command is in a loop (repeated failures)
        */
-      isLooping(command, context = "") {
-        const key = this._getKey(command, context);
+      isLooping(command, context2 = "") {
+        const key = this._getKey(command, context2);
         const record = this._attempts.get(key);
         if (!record) return false;
         if (record.attempts >= 2 && !record.success) {
@@ -6268,8 +6268,8 @@ var init_loop_detector = __esm({
       /**
        * Check if we should escalate to user
        */
-      shouldEscalate(command, context = "") {
-        const key = this._getKey(command, context);
+      shouldEscalate(command, context2 = "") {
+        const key = this._getKey(command, context2);
         const record = this._attempts.get(key);
         if (!record) return false;
         return record.attempts >= this.maxAttempts && !record.success;
@@ -6277,8 +6277,8 @@ var init_loop_detector = __esm({
       /**
        * Get escalation message for user
        */
-      getEscalationInfo(command, context = "") {
-        const key = this._getKey(command, context);
+      getEscalationInfo(command, context2 = "") {
+        const key = this._getKey(command, context2);
         const record = this._attempts.get(key);
         if (!record) {
           return null;
@@ -6287,7 +6287,7 @@ var init_loop_detector = __esm({
         return {
           status: "BLOCKED",
           command,
-          context,
+          context: context2,
           attempts: record.attempts,
           duration: record.lastAttempt - record.firstAttempt,
           errorPattern,
@@ -6299,8 +6299,8 @@ var init_loop_detector = __esm({
       /**
        * Mark a command as successful (resets tracking)
        */
-      recordSuccess(command, context = "") {
-        const key = this._getKey(command, context);
+      recordSuccess(command, context2 = "") {
+        const key = this._getKey(command, context2);
         const record = this._attempts.get(key);
         if (record) {
           record.success = true;
@@ -6312,8 +6312,8 @@ var init_loop_detector = __esm({
       /**
        * Clear all tracking for a command
        */
-      clearTracking(command, context = "") {
-        const key = this._getKey(command, context);
+      clearTracking(command, context2 = "") {
+        const key = this._getKey(command, context2);
         this._attempts.delete(key);
       }
       /**
@@ -6374,7 +6374,7 @@ var init_loop_detector = __esm({
 function requiresReasoning(commandName) {
   return REASONING_REQUIRED_COMMANDS.includes(commandName);
 }
-async function reason(commandName, context, state) {
+async function reason(commandName, context2, state) {
   const steps = [];
   const plan = [];
   const criticalIssues = [];
@@ -6398,7 +6398,7 @@ async function reason(commandName, context, state) {
       plan.push("Update metrics");
       break;
     case "feature":
-      if (context.params.description || context.params.feature) {
+      if (context2.params.description || context2.params.feature) {
         steps.push({ step: "Has feature description", passed: true });
       } else {
         steps.push({ step: "Has feature description", passed: false, details: "No description provided" });
@@ -6416,7 +6416,7 @@ async function reason(commandName, context, state) {
       plan.push("Suggest starting first task");
       break;
     case "spec":
-      if (context.params.feature || context.params.name) {
+      if (context2.params.feature || context2.params.name) {
         steps.push({ step: "Has spec name", passed: true });
       } else {
         steps.push({ step: "Has spec name", passed: false, details: "No spec name provided" });
@@ -6885,7 +6885,7 @@ var init_memory_system = __esm({
       async savePatterns(projectId) {
         return this.save(projectId);
       }
-      async recordDecision(projectId, key, value, context = "") {
+      async recordDecision(projectId, key, value, context2 = "") {
         const patterns = await this.load(projectId);
         const now = getTimestamp();
         if (!patterns.decisions[key]) {
@@ -6895,15 +6895,15 @@ var init_memory_system = __esm({
             firstSeen: now,
             lastSeen: now,
             confidence: "low",
-            contexts: [context].filter(Boolean)
+            contexts: [context2].filter(Boolean)
           };
         } else {
           const decision = patterns.decisions[key];
           if (decision.value === value) {
             decision.count++;
             decision.lastSeen = now;
-            if (context && !decision.contexts.includes(context)) {
-              decision.contexts.push(context);
+            if (context2 && !decision.contexts.includes(context2)) {
+              decision.contexts.push(context2);
             }
             if (decision.count >= 5) {
               decision.confidence = "high";
@@ -7093,11 +7093,11 @@ var init_memory_system = __esm({
           (m) => m.title.toLowerCase().includes(queryLower) || m.content.toLowerCase().includes(queryLower)
         );
       }
-      async getRelevantMemories(projectId, context, limit = 5) {
+      async getRelevantMemories(projectId, context2, limit = 5) {
         const db = await this.load(projectId);
         const scored = db.memories.map((memory) => {
           let score = 0;
-          const contextTags = this._extractContextTags(context);
+          const contextTags = this._extractContextTags(context2);
           for (const tag of memory.tags || []) {
             if (contextTags.includes(tag)) score += 10;
           }
@@ -7105,7 +7105,7 @@ var init_memory_system = __esm({
           const daysSinceUpdate = age / (1e3 * 60 * 60 * 24);
           score += Math.max(0, 5 - daysSinceUpdate);
           if (memory.userTriggered) score += 5;
-          const keywords = this._extractKeywords(context);
+          const keywords = this._extractKeywords(context2);
           for (const keyword of keywords) {
             if (memory.content.toLowerCase().includes(keyword)) score += 2;
             if (memory.title.toLowerCase().includes(keyword)) score += 3;
@@ -7114,7 +7114,7 @@ var init_memory_system = __esm({
         });
         return scored.filter((m) => m._score > 0).sort((a, b) => b._score - a._score).slice(0, limit).map(({ _score, ...memory }) => memory);
       }
-      _extractContextTags(context) {
+      _extractContextTags(context2) {
         const tags = [];
         const commandTags = {
           ship: [MEMORY_TAGS.COMMIT_STYLE, MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR],
@@ -7123,23 +7123,23 @@ var init_memory_system = __esm({
           analyze: [MEMORY_TAGS.TECH_STACK, MEMORY_TAGS.ARCHITECTURE],
           spec: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.CODE_STYLE]
         };
-        if (context.commandName && commandTags[context.commandName]) {
-          tags.push(...commandTags[context.commandName]);
+        if (context2.commandName && commandTags[context2.commandName]) {
+          tags.push(...commandTags[context2.commandName]);
         }
         return tags;
       }
-      _extractKeywords(context) {
+      _extractKeywords(context2) {
         const keywords = [];
-        if (context.params?.description) {
-          keywords.push(...context.params.description.toLowerCase().split(/\s+/));
+        if (context2.params?.description) {
+          keywords.push(...context2.params.description.toLowerCase().split(/\s+/));
         }
-        if (context.params?.feature) {
-          keywords.push(...context.params.feature.toLowerCase().split(/\s+/));
+        if (context2.params?.feature) {
+          keywords.push(...context2.params.feature.toLowerCase().split(/\s+/));
         }
         const stopWords = ["the", "a", "an", "is", "are", "to", "for", "and", "or", "in"];
         return keywords.filter((k) => k.length > 2 && !stopWords.includes(k));
       }
-      async autoRemember(projectId, decisionType, value, context = "") {
+      async autoRemember(projectId, decisionType, value, context2 = "") {
         const tagMap = {
           commit_footer: [MEMORY_TAGS.COMMIT_STYLE],
           branch_naming: [MEMORY_TAGS.BRANCH_NAMING],
@@ -7158,8 +7158,8 @@ var init_memory_system = __esm({
         } else {
           await this.createMemory(projectId, {
             title: `Preference: ${decisionType}`,
-            content: `${decisionType}: ${value}${context ? `
-Context: ${context}` : ""}`,
+            content: `${decisionType}: ${value}${context2 ? `
+Context: ${context2}` : ""}`,
             tags,
             userTriggered: true
           });
@@ -7222,11 +7222,11 @@ Context: ${context}` : ""}`,
       searchMemories(projectId, query) {
         return this._semanticMemories.searchMemories(projectId, query);
       }
-      getRelevantMemories(projectId, context, limit) {
-        return this._semanticMemories.getRelevantMemories(projectId, context, limit);
+      getRelevantMemories(projectId, context2, limit) {
+        return this._semanticMemories.getRelevantMemories(projectId, context2, limit);
       }
-      autoRemember(projectId, decisionType, value, context) {
-        return this._semanticMemories.autoRemember(projectId, decisionType, value, context);
+      autoRemember(projectId, decisionType, value, context2) {
+        return this._semanticMemories.autoRemember(projectId, decisionType, value, context2);
       }
       getAllMemories(projectId) {
         return this._semanticMemories.getAllMemories(projectId);
@@ -7255,8 +7255,8 @@ Context: ${context}` : ""}`,
       savePatterns(projectId) {
         return this._patternStore.savePatterns(projectId);
       }
-      recordDecision(projectId, key, value, context) {
-        return this._patternStore.recordDecision(projectId, key, value, context);
+      recordDecision(projectId, key, value, context2) {
+        return this._patternStore.recordDecision(projectId, key, value, context2);
       }
       getDecision(projectId, key) {
         return this._patternStore.getDecision(projectId, key);
@@ -7298,10 +7298,10 @@ Context: ${context}` : ""}`,
         if (pattern) return pattern.value;
         return null;
       }
-      async learnDecision(projectId, key, value, context = "") {
+      async learnDecision(projectId, key, value, context2 = "") {
         this.setSession(`decision:${key}`, value);
-        await this.recordDecision(projectId, key, value, context);
-        await this.appendHistory(projectId, { type: "decision", key, value, context });
+        await this.recordDecision(projectId, key, value, context2);
+        await this.appendHistory(projectId, { type: "decision", key, value, context: context2 });
       }
       /**
        * Reset internal state (for testing)
@@ -7351,11 +7351,11 @@ function formatWarnings(result) {
   }
   return output;
 }
-async function verifyDone(context) {
+async function verifyDone(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const nowPath = context.paths.now;
+  const nowPath = context2.paths.now;
   try {
     const nowContent = await fs18.readFile(nowPath, "utf-8");
     actual.nowExists = true;
@@ -7383,7 +7383,7 @@ async function verifyDone(context) {
       throw error;
     }
   }
-  const nextPath = context.paths.next;
+  const nextPath = context2.paths.next;
   try {
     const nextContent = await fs18.readFile(nextPath, "utf-8");
     actual.nextExists = true;
@@ -7397,7 +7397,7 @@ async function verifyDone(context) {
       throw error;
     }
   }
-  const metricsPath = context.paths.metrics;
+  const metricsPath = context2.paths.metrics;
   try {
     await fs18.access(path17.dirname(metricsPath), fs18.constants.W_OK);
     actual.metricsWritable = true;
@@ -7416,13 +7416,13 @@ async function verifyDone(context) {
     recommendations
   };
 }
-async function verifyShip(context) {
+async function verifyShip(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
   try {
     const gitStatus = execSync2("git status --porcelain", {
-      cwd: context.projectPath,
+      cwd: context2.projectPath,
       encoding: "utf-8"
     });
     actual.hasUncommittedChanges = gitStatus.trim().length > 0;
@@ -7434,7 +7434,7 @@ async function verifyShip(context) {
   } catch (error) {
     actual.gitAvailable = false;
   }
-  const pkgPath = path17.join(context.projectPath, "package.json");
+  const pkgPath = path17.join(context2.projectPath, "package.json");
   try {
     const pkgContent = await fs18.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
@@ -7450,11 +7450,11 @@ async function verifyShip(context) {
       throw error;
     }
   }
-  const shippedPath = context.paths.shipped;
+  const shippedPath = context2.paths.shipped;
   try {
     const shippedContent = await fs18.readFile(shippedPath, "utf-8");
     actual.shippedExists = true;
-    const featureName = context.params.feature || context.params.description;
+    const featureName = context2.params.feature || context2.params.description;
     if (featureName) {
       const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const todayPattern = new RegExp(`${today}.*${escapeRegex(featureName)}`, "i");
@@ -7490,11 +7490,11 @@ async function verifyShip(context) {
     recommendations
   };
 }
-async function verifyFeature(context) {
+async function verifyFeature(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const nextPath = context.paths.next;
+  const nextPath = context2.paths.next;
   try {
     const nextContent = await fs18.readFile(nextPath, "utf-8");
     actual.nextExists = true;
@@ -7513,11 +7513,11 @@ async function verifyFeature(context) {
       throw error;
     }
   }
-  const roadmapPath = context.paths.roadmap;
+  const roadmapPath = context2.paths.roadmap;
   try {
     const roadmapContent = await fs18.readFile(roadmapPath, "utf-8");
     actual.roadmapExists = true;
-    const featureName = context.params.description || context.params.feature;
+    const featureName = context2.params.description || context2.params.feature;
     if (featureName) {
       const featurePattern = new RegExp(escapeRegex(featureName), "i");
       if (featurePattern.test(roadmapContent)) {
@@ -7532,7 +7532,7 @@ async function verifyFeature(context) {
       throw error;
     }
   }
-  const nowPath = context.paths.now;
+  const nowPath = context2.paths.now;
   try {
     const nowContent = await fs18.readFile(nowPath, "utf-8");
     actual.hasActiveTask = nowContent.trim().length > 0 && !nowContent.includes("No current task");
@@ -7553,18 +7553,18 @@ async function verifyFeature(context) {
     recommendations
   };
 }
-async function verifyNow(context) {
+async function verifyNow(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const nowPath = context.paths.now;
+  const nowPath = context2.paths.now;
   try {
     const nowContent = await fs18.readFile(nowPath, "utf-8");
     actual.nowExists = true;
     actual.nowContent = nowContent.trim();
     const hasRealTask = nowContent.trim().length > 0 && !nowContent.includes("No current task") && !nowContent.match(/^#\s*NOW\s*$/m);
     actual.hasActiveTask = hasRealTask;
-    if (hasRealTask && context.params.task) {
+    if (hasRealTask && context2.params.task) {
       const taskPreview = nowContent.substring(0, 50).replace(/\n/g, " ");
       warnings.push(`Replacing existing task: "${taskPreview}..."`);
       recommendations.push("Use /p:done first to track completion");
@@ -7577,12 +7577,12 @@ async function verifyNow(context) {
       throw error;
     }
   }
-  const nextPath = context.paths.next;
+  const nextPath = context2.paths.next;
   try {
     const nextContent = await fs18.readFile(nextPath, "utf-8");
     const pendingTasks = (nextContent.match(/- \[ \]/g) || []).length;
     actual.pendingTasks = pendingTasks;
-    if (!context.params.task && pendingTasks > 0) {
+    if (!context2.params.task && pendingTasks > 0) {
       recommendations.push(`${pendingTasks} tasks available in queue`);
     }
   } catch (error) {
@@ -7599,11 +7599,11 @@ async function verifyNow(context) {
     recommendations
   };
 }
-async function verifyInit(context) {
+async function verifyInit(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path17.join(context.projectPath, ".prjct/prjct.config.json");
+  const configPath = path17.join(context2.projectPath, ".prjct/prjct.config.json");
   try {
     const configContent = await fs18.readFile(configPath, "utf-8");
     actual.alreadyInitialized = true;
@@ -7648,11 +7648,11 @@ async function verifyInit(context) {
     recommendations
   };
 }
-async function verifySync(context) {
+async function verifySync(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const configPath = path17.join(context.projectPath, ".prjct/prjct.config.json");
+  const configPath = path17.join(context2.projectPath, ".prjct/prjct.config.json");
   try {
     const configContent = await fs18.readFile(configPath, "utf-8");
     actual.hasConfig = true;
@@ -7693,7 +7693,7 @@ async function verifySync(context) {
     recommendations
   };
 }
-async function verifyAnalyze(context) {
+async function verifyAnalyze(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
@@ -7701,7 +7701,7 @@ async function verifyAnalyze(context) {
   actual.detectedFiles = [];
   for (const file of files) {
     try {
-      await fs18.access(path17.join(context.projectPath, file));
+      await fs18.access(path17.join(context2.projectPath, file));
       actual.detectedFiles.push(file);
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -7717,7 +7717,7 @@ async function verifyAnalyze(context) {
   actual.detectedSrcDirs = [];
   for (const dir of srcDirs) {
     try {
-      const stat = await fs18.stat(path17.join(context.projectPath, dir));
+      const stat = await fs18.stat(path17.join(context2.projectPath, dir));
       if (stat.isDirectory()) {
         ;
         actual.detectedSrcDirs.push(dir);
@@ -7736,11 +7736,11 @@ async function verifyAnalyze(context) {
     recommendations
   };
 }
-async function verifySpec(context) {
+async function verifySpec(context2) {
   const warnings = [];
   const recommendations = [];
   const actual = {};
-  const specsPath = context.paths.specs;
+  const specsPath = context2.paths.specs;
   try {
     await fs18.access(specsPath);
     actual.specsExists = true;
@@ -7755,7 +7755,7 @@ async function verifySpec(context) {
       throw error;
     }
   }
-  const featureName = context.params.feature || context.params.name || context.params.description;
+  const featureName = context2.params.feature || context2.params.name || context2.params.description;
   if (featureName && actual.existingSpecs) {
     const slug = featureName.toLowerCase().replace(/\s+/g, "-");
     if (actual.existingSpecs.includes(`${slug}.md`)) {
@@ -7770,7 +7770,7 @@ async function verifySpec(context) {
     recommendations
   };
 }
-async function verify(commandName, context, state) {
+async function verify(commandName, context2, state) {
   const verifier = verifiers[commandName];
   if (!verifier) {
     return {
@@ -7781,7 +7781,7 @@ async function verify(commandName, context, state) {
     };
   }
   try {
-    return await verifier(context, state);
+    return await verifier(context2, state);
   } catch (error) {
     return {
       verified: false,
@@ -7791,10 +7791,10 @@ async function verify(commandName, context, state) {
     };
   }
 }
-async function prepareCommand(commandName, context, state) {
-  const verification = await verify(commandName, context, state);
+async function prepareCommand(commandName, context2, state) {
+  const verification = await verify(commandName, context2, state);
   return {
-    ...context,
+    ...context2,
     groundTruth: {
       ...verification,
       verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7894,15 +7894,15 @@ var init_constants = __esm({
 });
 
 // core/agentic/plan-mode.ts
-function generateApprovalPrompt(commandName, context) {
+function generateApprovalPrompt(commandName, context2) {
   const prompts = {
     ship: {
       title: "Ship Confirmation",
       message: "Ready to commit and push changes?",
       details: [
-        `Branch: ${context.branch || "current"}`,
-        `Files: ${context.changedFiles?.length || 0} changed`,
-        `Commit: "${context.commitMessage || "No message"}"`
+        `Branch: ${context2.branch || "current"}`,
+        `Files: ${context2.changedFiles?.length || 0} changed`,
+        `Commit: "${context2.commitMessage || "No message"}"`
       ],
       options: [
         { key: "y", label: "Yes, ship it", action: "approve" },
@@ -7913,7 +7913,7 @@ function generateApprovalPrompt(commandName, context) {
     cleanup: {
       title: "Cleanup Confirmation",
       message: "This will delete files/code. Continue?",
-      details: [`Files to delete: ${context.filesToDelete?.length || 0}`, `Code to remove: ${context.linesOfCode || 0} lines`],
+      details: [`Files to delete: ${context2.filesToDelete?.length || 0}`, `Code to remove: ${context2.linesOfCode || 0} lines`],
       options: [
         { key: "y", label: "Yes, cleanup", action: "approve" },
         { key: "n", label: "No, cancel", action: "reject" },
@@ -7922,8 +7922,8 @@ function generateApprovalPrompt(commandName, context) {
     },
     git: {
       title: "Git Operation Confirmation",
-      message: `Execute: ${context.operation || "git operation"}?`,
-      details: context.warnings || [],
+      message: `Execute: ${context2.operation || "git operation"}?`,
+      details: context2.warnings || [],
       options: [
         { key: "y", label: "Yes, execute", action: "approve" },
         { key: "n", label: "No, cancel", action: "reject" }
@@ -8234,8 +8234,8 @@ var init_plan_mode = __esm({
       /**
        * Generate approval prompt for destructive commands (class method wrapper)
        */
-      generateApprovalPrompt(commandName, context) {
-        return generateApprovalPrompt(commandName, context);
+      generateApprovalPrompt(commandName, context2) {
+        return generateApprovalPrompt(commandName, context2);
       }
       /**
        * Format plan status for display
@@ -8380,53 +8380,53 @@ var init_template_executor = __esm({
       /**
        * Build prompt that tells Claude to execute templates agentically
        */
-      buildAgenticPrompt(context) {
-        const requiresOrchestration = this.requiresOrchestration(context.command);
+      buildAgenticPrompt(context2) {
+        const requiresOrchestration = this.requiresOrchestration(context2.command);
         const prompt = `
 ## Agentic Execution Mode
 
 You are executing a prjct command. Follow the template-first approach.
 
 ### Context
-- Command: ${context.command}
-- Args: ${context.args}
-- Project: ${context.projectPath}
-- Project ID: ${context.projectId}
+- Command: ${context2.command}
+- Args: ${context2.args}
+- Project: ${context2.projectPath}
+- Project ID: ${context2.projectId}
 
 ### Paths (Read as needed)
-- Orchestrator: ${context.paths.orchestrator}
-- Agent Routing: ${context.paths.agentRouting}
-- Task Fragmentation: ${context.paths.taskFragmentation}
-- Command Template: ${context.paths.commandTemplate}
-- Repo Analysis: ${context.paths.repoAnalysis}
-- Agents Directory: ${context.paths.agentsDir}
-- Skills Directory: ${context.paths.skillsDir}
-- State JSON: ${context.paths.stateJson}
+- Orchestrator: ${context2.paths.orchestrator}
+- Agent Routing: ${context2.paths.agentRouting}
+- Task Fragmentation: ${context2.paths.taskFragmentation}
+- Command Template: ${context2.paths.commandTemplate}
+- Repo Analysis: ${context2.paths.repoAnalysis}
+- Agents Directory: ${context2.paths.agentsDir}
+- Skills Directory: ${context2.paths.skillsDir}
+- State JSON: ${context2.paths.stateJson}
 
 ### Instructions
 
-1. **Read the command template** (${context.paths.commandTemplate})
+1. **Read the command template** (${context2.paths.commandTemplate})
 
 2. **Check if orchestration is needed**
    - This command ${requiresOrchestration ? "REQUIRES" : "does NOT require"} orchestration
    ${requiresOrchestration ? `
 3. **Orchestration steps:**
-   - Read: ${context.paths.orchestrator}
-   - Read: ${context.paths.repoAnalysis} to understand project technologies
-   - Analyze the task: "${context.args}"
+   - Read: ${context2.paths.orchestrator}
+   - Read: ${context2.paths.repoAnalysis} to understand project technologies
+   - Analyze the task: "${context2.args}"
    - Determine which domains are ACTUALLY relevant based on:
      a) What the task requires
      b) What technologies exist in this project
-     c) What agents are available in ${context.paths.agentsDir}
+     c) What agents are available in ${context2.paths.agentsDir}
 
-   - **IMPORTANTE**: Los agentes en ${context.paths.agentsDir} YA son espec\xEDficos del proyecto
+   - **IMPORTANTE**: Los agentes en ${context2.paths.agentsDir} YA son espec\xEDficos del proyecto
      (fueron generados durante p. sync con las tecnolog\xEDas reales)
 
    - SIEMPRE usar el especialista si existe para el dominio
    - Solo usar generalista si NO existe agente para ese dominio
 
-   - Check if task should be fragmented (read: ${context.paths.taskFragmentation})
-   - If agents loaded, check their skills and load from ${context.paths.skillsDir}
+   - Check if task should be fragmented (read: ${context2.paths.taskFragmentation})
+   - If agents loaded, check their skills and load from ${context2.paths.skillsDir}
 ` : `
 3. **Simple execution:**
    - Execute the command template directly
@@ -8466,7 +8466,7 @@ When fragmenting tasks:
 `;
         return {
           prompt,
-          context,
+          context: context2,
           requiresOrchestration
         };
       }
@@ -9049,7 +9049,7 @@ var init_command_executor = __esm({
               console.warn(`\u26A0\uFE0F  Orchestrator warning: ${error.message}`);
             }
           }
-          const context = {
+          const context2 = {
             ...metadataContext,
             agentsPath: agenticExecContext.paths.agentsDir,
             agentRoutingPath: agenticExecContext.paths.agentRouting,
@@ -9085,7 +9085,7 @@ var init_command_executor = __esm({
           };
           const prompt = prompt_builder_default.build(
             template,
-            context,
+            context2,
             state,
             null,
             learnedPatterns,
@@ -9103,7 +9103,7 @@ var init_command_executor = __esm({
           return {
             success: true,
             template,
-            context,
+            context: context2,
             state,
             prompt,
             agenticDelegation: true,
@@ -9111,8 +9111,8 @@ var init_command_executor = __esm({
             agenticExecContext,
             agenticPrompt: agenticInfo.prompt,
             requiresOrchestration: agenticInfo.requiresOrchestration,
-            agentsPath: context.agentsPath,
-            agentRoutingPath: context.agentRoutingPath,
+            agentsPath: context2.agentsPath,
+            agentRoutingPath: context2.agentRoutingPath,
             orchestratorPath: agenticExecContext.paths.orchestrator,
             taskFragmentationPath: agenticExecContext.paths.taskFragmentation,
             reasoning,
@@ -9202,13 +9202,13 @@ var init_command_executor = __esm({
         try {
           const template = await template_loader_default.load(commandName);
           const allowedTools = template.frontmatter["allowed-tools"] || [];
-          const context = await context_builder_default.build(projectPath);
+          const context2 = await context_builder_default.build(projectPath);
           const tools = {
             read: /* @__PURE__ */ __name(async (filePath) => this.executeTool("Read", [filePath], allowedTools), "read"),
             write: /* @__PURE__ */ __name(async (filePath, content) => this.executeTool("Write", [filePath, content], allowedTools), "write"),
             bash: /* @__PURE__ */ __name(async (command) => this.executeTool("Bash", [command], allowedTools), "bash")
           };
-          const result = await executionFn(tools, context);
+          const result = await executionFn(tools, context2);
           return {
             success: true,
             result
@@ -10436,6 +10436,7 @@ var init_analysis2 = __esm({
     init_analyzer2();
     init_generator();
     init_command_installer();
+    init_services();
     AnalysisCommands = class extends PrjctCommandsBase {
       static {
         __name(this, "AnalysisCommands");
@@ -10448,7 +10449,7 @@ var init_analysis2 = __esm({
           await this.initializeAgent();
           console.log("\u{1F50D} Analyzing repository...\n");
           analyzer_default2.init(projectPath);
-          const context = await context_builder_default.build(projectPath, options);
+          const context2 = await context_builder_default.build(projectPath, options);
           const analysisData = {
             packageJson: await analyzer_default2.readPackageJson(),
             cargoToml: await analyzer_default2.readCargoToml(),
@@ -10467,7 +10468,7 @@ var init_analysis2 = __esm({
           };
           const summary = this._generateAnalysisSummary(analysisData, projectPath);
           const projectId = await config_manager_default.getProjectId(projectPath);
-          const summaryPath = context.paths.analysis || path_manager_default.getFilePath(
+          const summaryPath = context2.paths.analysis || path_manager_default.getFilePath(
             projectId,
             "analysis",
             "repo-summary.md"
@@ -10579,43 +10580,71 @@ var init_analysis2 = __esm({
         return lines.join("\n");
       }
       /**
-       * /p:sync - Sync project state with raw data for Claude to analyze
+       * /p:sync - Comprehensive project sync
+       *
+       * Uses syncService to do ALL operations in one TypeScript execution:
+       * - Git analysis
+       * - Project stats
+       * - Agent generation
+       * - Context file generation
+       * - Skill configuration
+       * - State updates
        *
-       * AGENTIC: This command gathers RAW data and puts it in CLAUDE.md
-       * Claude then reads the data and decides what agents to create.
-       * NO hardcoded if/else logic for technology detection.
+       * This eliminates the need for Claude to make 50+ individual tool calls.
        */
       async sync(projectPath = process.cwd()) {
         try {
           const initResult = await this.ensureProjectInit(projectPath);
           if (!initResult.success) return initResult;
-          await this.initializeAgent();
-          console.log("\u{1F504} Syncing project state...\n");
-          console.log("\u{1F4CA} Running analysis...");
-          const analysisResult = await this.analyze({}, projectPath);
-          if (!analysisResult.success) {
-            console.error("\u274C Analysis failed");
-            return analysisResult;
+          console.log("\u{1F504} Syncing project...\n");
+          const result = await syncService.sync(projectPath);
+          if (!result.success) {
+            console.error("\u274C Sync failed:", result.error);
+            return { success: false, error: result.error };
           }
-          const projectId = await config_manager_default.getProjectId(projectPath);
-          await generateContext(projectId, projectPath);
           const globalConfigResult = await command_installer_default.installGlobalConfig();
           if (globalConfigResult.success) {
             console.log("\u{1F4DD} Updated ~/.claude/CLAUDE.md");
           }
-          await this.logToMemory(projectPath, "sync_complete", {
-            timestamp: date_helper_default.getTimestamp(),
-            projectId
-          });
-          console.log("\n\u2705 Sync complete!\n");
-          console.log("\u{1F4DD} Context: ~/.prjct-cli/projects/" + projectId + "/CLAUDE.md");
-          console.log("\n\u{1F4CB} CLAUDE.md contains RAW project data.");
-          console.log("\u{1F4A1} Claude reads this data and decides what specialists to create.\n");
-          console.log("Next steps:");
-          console.log("\u2022 Read CLAUDE.md to see project data");
-          console.log("\u2022 /p:feature \u2192 Add a feature");
+          console.log(`\u{1F504} Project synced to prjct v${result.cliVersion}
+`);
+          console.log("\u{1F4CA} Project Stats");
+          console.log(`\u251C\u2500\u2500 Files: ~${result.stats.fileCount}`);
+          console.log(`\u251C\u2500\u2500 Commits: ${result.git.commits}`);
+          console.log(`\u251C\u2500\u2500 Version: ${result.stats.version}`);
+          console.log(`\u2514\u2500\u2500 Stack: ${result.stats.ecosystem}
+`);
+          console.log("\u{1F33F} Git Status");
+          console.log(`\u251C\u2500\u2500 Branch: ${result.git.branch}`);
+          console.log(`\u251C\u2500\u2500 Uncommitted: ${result.git.hasChanges ? "Yes" : "Clean"}`);
+          console.log(`\u2514\u2500\u2500 Recent: ${result.git.weeklyCommits} commits this week
+`);
+          console.log("\u{1F4C1} Context Updated");
+          for (const file of result.contextFiles) {
+            console.log(`\u251C\u2500\u2500 ${file}`);
+          }
+          console.log("");
+          const workflowAgents = result.agents.filter((a) => a.type === "workflow").map((a) => a.name);
+          const domainAgents = result.agents.filter((a) => a.type === "domain").map((a) => a.name);
+          console.log(`\u{1F916} Agents Regenerated (${result.agents.length})`);
+          console.log(`\u251C\u2500\u2500 Workflow: ${workflowAgents.join(", ")}`);
+          console.log(`\u2514\u2500\u2500 Domain: ${domainAgents.join(", ") || "none"}
+`);
+          if (result.skills.length > 0) {
+            console.log("\u{1F4E6} Skills Configured");
+            for (const skill of result.skills) {
+              console.log(`\u251C\u2500\u2500 ${skill.agent}.md \u2192 ${skill.skill}`);
+            }
+            console.log("");
+          }
+          if (result.git.hasChanges) {
+            console.log("\u26A0\uFE0F  You have uncommitted changes\n");
+          } else {
+            console.log("\u2728 Repository is clean!\n");
+          }
           return {
-            success: true
+            success: true,
+            data: result
           };
         } catch (error) {
           console.error("\u274C Error:", error.message);
@@ -10758,12 +10787,12 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             return { success: false, error: "No project ID found" };
           }
           output_default.spin(`planning ${description}...`);
-          const context = await context_builder_default.build(projectPath, { description });
+          const context2 = await context_builder_default.build(projectPath, { description });
           const tasks = this._breakdownFeatureTasks(description);
           const featureId = generateUUID();
           const tasksWithAgents = [];
           for (const taskDesc of tasks) {
-            const agentResult = await this._assignAgentForTask(taskDesc, projectPath, context);
+            const agentResult = await this._assignAgentForTask(taskDesc, projectPath, context2);
             const agent = agentResult.agent?.name || "generalist";
             tasksWithAgents.push({ task: taskDesc, agent });
           }
@@ -10812,9 +10841,9 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             return { success: false, error: "No project ID found" };
           }
           output_default.spin("tracking bug...");
-          const context = await context_builder_default.build(projectPath, { description });
+          const context2 = await context_builder_default.build(projectPath, { description });
           const severity = this._detectBugSeverity(description);
-          const agentResult = await this._assignAgentForTask(`fix bug: ${description}`, projectPath, context);
+          const agentResult = await this._assignAgentForTask(`fix bug: ${description}`, projectPath, context2);
           const agent = agentResult.agent?.name || "generalist";
           const priorityMap = {
             "critical": "critical",
@@ -10990,8 +11019,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path27.join(globalPath2, "planning", "specs");
             try {
-              const fs28 = await import("fs/promises");
-              const files = await fs28.readdir(specsPath2);
+              const fs30 = await import("fs/promises");
+              const files = await fs30.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -11376,6 +11405,790 @@ var init_breakdown_service = __esm({
   }
 });
 
+// core/services/sync-service.ts
+import fs27 from "fs/promises";
+import path28 from "path";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execAsync3, SyncService, syncService;
+var init_sync_service = __esm({
+  "core/services/sync-service.ts"() {
+    "use strict";
+    init_path_manager();
+    init_config_manager();
+    init_date_helper();
+    execAsync3 = promisify5(exec5);
+    SyncService = class {
+      static {
+        __name(this, "SyncService");
+      }
+      projectPath;
+      projectId = null;
+      globalPath = "";
+      cliVersion = "0.0.0";
+      constructor() {
+        this.projectPath = process.cwd();
+      }
+      /**
+       * Main sync method - does everything in one call
+       */
+      async sync(projectPath = process.cwd()) {
+        this.projectPath = projectPath;
+        try {
+          this.projectId = await config_manager_default.getProjectId(projectPath);
+          if (!this.projectId) {
+            return {
+              success: false,
+              projectId: "",
+              cliVersion: "",
+              git: this.emptyGitData(),
+              stats: this.emptyStats(),
+              commands: this.emptyCommands(),
+              stack: this.emptyStack(),
+              agents: [],
+              skills: [],
+              contextFiles: [],
+              error: "No prjct project. Run p. init first."
+            };
+          }
+          this.globalPath = path_manager_default.getGlobalProjectPath(this.projectId);
+          this.cliVersion = await this.getCliVersion();
+          await this.ensureDirectories();
+          const git = await this.analyzeGit();
+          const stats = await this.gatherStats();
+          const commands = await this.detectCommands();
+          const stack = await this.detectStack();
+          const agents = await this.generateAgents(stack, stats);
+          const skills = this.configureSkills(agents);
+          const contextFiles = await this.generateContextFiles(git, stats, commands, agents);
+          await this.updateProjectJson(git, stats);
+          await this.updateStateJson(stats, stack);
+          await this.logToMemory(git, stats);
+          return {
+            success: true,
+            projectId: this.projectId,
+            cliVersion: this.cliVersion,
+            git,
+            stats,
+            commands,
+            stack,
+            agents,
+            skills,
+            contextFiles
+          };
+        } catch (error) {
+          return {
+            success: false,
+            projectId: this.projectId || "",
+            cliVersion: this.cliVersion,
+            git: this.emptyGitData(),
+            stats: this.emptyStats(),
+            commands: this.emptyCommands(),
+            stack: this.emptyStack(),
+            agents: [],
+            skills: [],
+            contextFiles: [],
+            error: error.message
+          };
+        }
+      }
+      // ==========================================================================
+      // DIRECTORY SETUP
+      // ==========================================================================
+      async ensureDirectories() {
+        const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
+        for (const dir of dirs) {
+          await fs27.mkdir(path28.join(this.globalPath, dir), { recursive: true });
+        }
+      }
+      // ==========================================================================
+      // GIT ANALYSIS
+      // ==========================================================================
+      async analyzeGit() {
+        const data = {
+          branch: "main",
+          commits: 0,
+          contributors: 0,
+          hasChanges: false,
+          stagedFiles: [],
+          modifiedFiles: [],
+          untrackedFiles: [],
+          recentCommits: [],
+          weeklyCommits: 0
+        };
+        try {
+          const { stdout: branch } = await execAsync3("git branch --show-current", {
+            cwd: this.projectPath
+          });
+          data.branch = branch.trim() || "main";
+          const { stdout: commits } = await execAsync3("git rev-list --count HEAD", {
+            cwd: this.projectPath
+          });
+          data.commits = parseInt(commits.trim()) || 0;
+          const { stdout: contributors } = await execAsync3("git shortlog -sn --all | wc -l", {
+            cwd: this.projectPath
+          });
+          data.contributors = parseInt(contributors.trim()) || 0;
+          const { stdout: status } = await execAsync3("git status --porcelain", {
+            cwd: this.projectPath
+          });
+          const lines = status.trim().split("\n").filter(Boolean);
+          data.hasChanges = lines.length > 0;
+          for (const line of lines) {
+            const code = line.substring(0, 2);
+            const file = line.substring(3);
+            if (code.startsWith("A") || code.startsWith("M ")) {
+              data.stagedFiles.push(file);
+            } else if (code.includes("M")) {
+              data.modifiedFiles.push(file);
+            } else if (code.startsWith("??")) {
+              data.untrackedFiles.push(file);
+            }
+          }
+          const { stdout: log } = await execAsync3(
+            'git log --oneline -20 --pretty=format:"%h|%s|%ad" --date=short',
+            { cwd: this.projectPath }
+          );
+          data.recentCommits = log.split("\n").filter(Boolean).map((line) => {
+            const [hash, message, date] = line.split("|");
+            return { hash, message, date };
+          });
+          const { stdout: weekly } = await execAsync3('git log --oneline --since="1 week ago" | wc -l', {
+            cwd: this.projectPath
+          });
+          data.weeklyCommits = parseInt(weekly.trim()) || 0;
+        } catch {
+        }
+        return data;
+      }
+      // ==========================================================================
+      // PROJECT STATS
+      // ==========================================================================
+      async gatherStats() {
+        const stats = {
+          fileCount: 0,
+          version: "0.0.0",
+          name: path28.basename(this.projectPath),
+          ecosystem: "unknown",
+          projectType: "simple",
+          languages: [],
+          frameworks: []
+        };
+        try {
+          const { stdout } = await execAsync3(
+            '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 }
+          );
+          stats.fileCount = parseInt(stdout.trim()) || 0;
+        } catch {
+          stats.fileCount = 0;
+        }
+        try {
+          const pkgPath = path28.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs27.readFile(pkgPath, "utf-8"));
+          stats.version = pkg.version || "0.0.0";
+          stats.name = pkg.name || stats.name;
+          stats.ecosystem = "JavaScript";
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          if (deps.react || deps["react-dom"]) stats.frameworks.push("React");
+          if (deps.next) stats.frameworks.push("Next.js");
+          if (deps.vue) stats.frameworks.push("Vue");
+          if (deps.express) stats.frameworks.push("Express");
+          if (deps.hono) stats.frameworks.push("Hono");
+          if (deps["@angular/core"]) stats.frameworks.push("Angular");
+          if (deps.svelte) stats.frameworks.push("Svelte");
+          if (pkg.devDependencies?.typescript || await this.fileExists("tsconfig.json")) {
+            stats.languages.push("TypeScript");
+          } else {
+            stats.languages.push("JavaScript");
+          }
+        } catch {
+        }
+        if (await this.fileExists("Cargo.toml")) {
+          stats.ecosystem = "Rust";
+          stats.languages.push("Rust");
+        }
+        if (await this.fileExists("go.mod")) {
+          stats.ecosystem = "Go";
+          stats.languages.push("Go");
+        }
+        if (await this.fileExists("requirements.txt") || await this.fileExists("pyproject.toml")) {
+          stats.ecosystem = "Python";
+          stats.languages.push("Python");
+        }
+        if (stats.fileCount > 300 || stats.frameworks.length >= 3) {
+          stats.projectType = "enterprise";
+        } else if (stats.fileCount > 50 || stats.frameworks.length >= 2) {
+          stats.projectType = "complex";
+        }
+        return stats;
+      }
+      // ==========================================================================
+      // COMMAND DETECTION
+      // ==========================================================================
+      async detectCommands() {
+        const commands = {
+          install: "npm install",
+          run: "npm run",
+          test: "npm test",
+          build: "npm run build",
+          dev: "npm run dev",
+          lint: "npm run lint",
+          format: "npm run format"
+        };
+        if (await this.fileExists("bun.lockb")) {
+          commands.install = "bun install";
+          commands.run = "bun run";
+          commands.test = "bun test";
+          commands.build = "bun run build";
+          commands.dev = "bun run dev";
+          commands.lint = "bun run lint";
+          commands.format = "bun run format";
+        } else if (await this.fileExists("pnpm-lock.yaml")) {
+          commands.install = "pnpm install";
+          commands.run = "pnpm run";
+          commands.test = "pnpm test";
+          commands.build = "pnpm run build";
+          commands.dev = "pnpm run dev";
+          commands.lint = "pnpm run lint";
+          commands.format = "pnpm run format";
+        } else if (await this.fileExists("yarn.lock")) {
+          commands.install = "yarn";
+          commands.run = "yarn";
+          commands.test = "yarn test";
+          commands.build = "yarn build";
+          commands.dev = "yarn dev";
+          commands.lint = "yarn lint";
+          commands.format = "yarn format";
+        }
+        if (await this.fileExists("Cargo.toml")) {
+          commands.install = "cargo build";
+          commands.run = "cargo run";
+          commands.test = "cargo test";
+          commands.build = "cargo build --release";
+          commands.dev = "cargo run";
+          commands.lint = "cargo clippy";
+          commands.format = "cargo fmt";
+        }
+        if (await this.fileExists("go.mod")) {
+          commands.install = "go mod download";
+          commands.run = "go run .";
+          commands.test = "go test ./...";
+          commands.build = "go build";
+          commands.dev = "go run .";
+          commands.lint = "golangci-lint run";
+          commands.format = "go fmt ./...";
+        }
+        return commands;
+      }
+      // ==========================================================================
+      // STACK DETECTION
+      // ==========================================================================
+      async detectStack() {
+        const stack = {
+          hasFrontend: false,
+          hasBackend: false,
+          hasDatabase: false,
+          hasDocker: false,
+          hasTesting: false,
+          frontendType: null,
+          frameworks: []
+        };
+        try {
+          const pkgPath = path28.join(this.projectPath, "package.json");
+          const pkg = JSON.parse(await fs27.readFile(pkgPath, "utf-8"));
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          if (deps.react || deps.vue || deps.svelte || deps["@angular/core"]) {
+            stack.hasFrontend = true;
+            stack.frontendType = "web";
+          }
+          if (deps["react-native"] || deps.expo) {
+            stack.hasFrontend = true;
+            stack.frontendType = stack.frontendType === "web" ? "both" : "mobile";
+          }
+          if (deps.express || deps.fastify || deps.hono || deps.koa || deps.nest) {
+            stack.hasBackend = true;
+          }
+          if (deps.prisma || deps.mongoose || deps.pg || deps.mysql2 || deps.sequelize) {
+            stack.hasDatabase = true;
+          }
+          if (deps.jest || deps.vitest || deps.mocha || pkg.devDependencies?.["bun-types"]) {
+            stack.hasTesting = true;
+          }
+          if (deps.react) stack.frameworks.push("React");
+          if (deps.next) stack.frameworks.push("Next.js");
+          if (deps.express) stack.frameworks.push("Express");
+          if (deps.hono) stack.frameworks.push("Hono");
+        } catch {
+        }
+        stack.hasDocker = await this.fileExists("Dockerfile") || await this.fileExists("docker-compose.yml");
+        return stack;
+      }
+      // ==========================================================================
+      // AGENT GENERATION
+      // ==========================================================================
+      async generateAgents(stack, stats) {
+        const agents = [];
+        const agentsPath = path28.join(this.globalPath, "agents");
+        try {
+          const files = await fs27.readdir(agentsPath);
+          for (const file of files) {
+            if (file.endsWith(".md")) {
+              await fs27.unlink(path28.join(agentsPath, file));
+            }
+          }
+        } catch {
+        }
+        const workflowAgents = ["prjct-workflow", "prjct-planner", "prjct-shipper"];
+        for (const name of workflowAgents) {
+          await this.generateWorkflowAgent(name, agentsPath);
+          agents.push({ name, type: "workflow" });
+        }
+        if (stack.hasFrontend) {
+          await this.generateDomainAgent("frontend", agentsPath, stats, stack);
+          agents.push({ name: "frontend", type: "domain", skill: "javascript-typescript" });
+          await this.generateDomainAgent("uxui", agentsPath, stats, stack);
+          agents.push({ name: "uxui", type: "domain", skill: "frontend-design" });
+        }
+        if (stack.hasBackend) {
+          await this.generateDomainAgent("backend", agentsPath, stats, stack);
+          agents.push({ name: "backend", type: "domain", skill: "javascript-typescript" });
+        }
+        if (stack.hasDatabase) {
+          await this.generateDomainAgent("database", agentsPath, stats, stack);
+          agents.push({ name: "database", type: "domain" });
+        }
+        if (stack.hasTesting) {
+          await this.generateDomainAgent("testing", agentsPath, stats, stack);
+          agents.push({ name: "testing", type: "domain", skill: "developer-kit" });
+        }
+        if (stack.hasDocker) {
+          await this.generateDomainAgent("devops", agentsPath, stats, stack);
+          agents.push({ name: "devops", type: "domain", skill: "developer-kit" });
+        }
+        return agents;
+      }
+      async generateWorkflowAgent(name, agentsPath) {
+        let content = "";
+        try {
+          const templatePath = path28.join(
+            __dirname,
+            "..",
+            "..",
+            "templates",
+            "subagents",
+            "workflow",
+            `${name}.md`
+          );
+          content = await fs27.readFile(templatePath, "utf-8");
+        } catch {
+          content = this.generateMinimalWorkflowAgent(name);
+        }
+        await fs27.writeFile(path28.join(agentsPath, `${name}.md`), content, "utf-8");
+      }
+      async generateDomainAgent(name, agentsPath, stats, stack) {
+        let content = "";
+        try {
+          const templatePath = path28.join(
+            __dirname,
+            "..",
+            "..",
+            "templates",
+            "subagents",
+            "domain",
+            `${name}.md`
+          );
+          content = await fs27.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 fs27.writeFile(path28.join(agentsPath, `${name}.md`), content, "utf-8");
+      }
+      generateMinimalWorkflowAgent(name) {
+        const descriptions = {
+          "prjct-workflow": "Task lifecycle: now, done, pause, resume",
+          "prjct-planner": "Planning: task, prd, spec, bug",
+          "prjct-shipper": "Shipping: ship, merge, review"
+        };
+        return `---
+name: ${name}
+description: ${descriptions[name] || "Workflow agent"}
+tools: Read, Write, Glob
+---
+
+# ${name.toUpperCase()}
+
+Workflow agent for prjct operations.
+
+## Project Context
+
+When invoked:
+1. Read \`.prjct/prjct.config.json\` \u2192 extract \`projectId\`
+2. Read \`~/.prjct-cli/projects/{projectId}/storage/state.json\`
+3. Execute requested operation
+`;
+      }
+      generateMinimalDomainAgent(name, stats, stack) {
+        return `---
+name: ${name}
+description: ${name.charAt(0).toUpperCase() + name.slice(1)} specialist for ${stats.name}
+tools: Read, Write, Glob, Grep
+skills: []
+---
+
+# ${name.toUpperCase()} AGENT
+
+Domain specialist for ${name} tasks.
+
+## Project Context
+
+- **Project**: ${stats.name}
+- **Ecosystem**: ${stats.ecosystem}
+- **Frameworks**: ${stack.frameworks.join(", ") || "None detected"}
+
+## Your Role
+
+You are the ${name} expert for this project. Apply best practices for the detected stack.
+`;
+      }
+      // ==========================================================================
+      // SKILL CONFIGURATION
+      // ==========================================================================
+      configureSkills(agents) {
+        const skills = [];
+        for (const agent of agents) {
+          if (agent.skill) {
+            skills.push({ agent: agent.name, skill: agent.skill });
+          }
+        }
+        const skillsConfig = {
+          projectId: this.projectId,
+          syncedAt: date_helper_default.getTimestamp(),
+          skills: skills.map((s) => ({
+            name: s.skill,
+            linkedAgents: [s.agent]
+          })),
+          agentSkillMap: Object.fromEntries(skills.map((s) => [s.agent, s.skill]))
+        };
+        fs27.writeFile(
+          path28.join(this.globalPath, "config", "skills.json"),
+          JSON.stringify(skillsConfig, null, 2),
+          "utf-8"
+        ).catch(() => {
+        });
+        return skills;
+      }
+      // ==========================================================================
+      // CONTEXT FILE GENERATION
+      // ==========================================================================
+      async generateContextFiles(git, stats, commands, agents) {
+        const contextPath = path28.join(this.globalPath, "context");
+        const files = [];
+        await this.generateClaudeMd(contextPath, git, stats, commands, agents);
+        files.push("context/CLAUDE.md");
+        await this.generateNowMd(contextPath);
+        files.push("context/now.md");
+        await this.generateNextMd(contextPath);
+        files.push("context/next.md");
+        await this.generateIdeasMd(contextPath);
+        files.push("context/ideas.md");
+        await this.generateShippedMd(contextPath);
+        files.push("context/shipped.md");
+        return files;
+      }
+      async generateClaudeMd(contextPath, git, stats, commands, agents) {
+        const workflowAgents = agents.filter((a) => a.type === "workflow").map((a) => a.name);
+        const domainAgents = agents.filter((a) => a.type === "domain").map((a) => a.name);
+        const content = `# ${stats.name} - Project Rules
+<!-- projectId: ${this.projectId} -->
+<!-- Generated: ${date_helper_default.getTimestamp()} -->
+<!-- Ecosystem: ${stats.ecosystem} | Type: ${stats.projectType} -->
+
+## THIS PROJECT (${stats.ecosystem})
+
+**Type:** ${stats.projectType}
+**Path:** ${this.projectPath}
+
+### Commands (USE THESE, NOT OTHERS)
+
+| Action | Command |
+|--------|---------|
+| Install dependencies | \`${commands.install}\` |
+| Run dev server | \`${commands.dev}\` |
+| Run tests | \`${commands.test}\` |
+| Build | \`${commands.build}\` |
+| Lint | \`${commands.lint}\` |
+| Format | \`${commands.format}\` |
+
+### Code Conventions
+
+- **Languages**: ${stats.languages.join(", ") || "Not detected"}
+- **Frameworks**: ${stats.frameworks.join(", ") || "Not detected"}
+
+---
+
+## PRJCT RULES
+
+### Path Resolution
+**ALL prjct writes go to**: \`~/.prjct-cli/projects/${this.projectId}/\`
+- NEVER write to \`.prjct/\`
+- NEVER write to \`./\` for prjct data
+
+### Workflow
+\`\`\`
+p. sync \u2192 p. task "desc" \u2192 [work] \u2192 p. done \u2192 p. ship
+\`\`\`
+
+| Command | Action |
+|---------|--------|
+| \`p. sync\` | Re-analyze project |
+| \`p. task X\` | Start task |
+| \`p. done\` | Complete subtask |
+| \`p. ship X\` | Ship feature |
+
+---
+
+## PROJECT STATE
+
+| Field | Value |
+|-------|-------|
+| Name | ${stats.name} |
+| Version | ${stats.version} |
+| Ecosystem | ${stats.ecosystem} |
+| Branch | ${git.branch} |
+| Files | ~${stats.fileCount} |
+| Commits | ${git.commits} |
+
+---
+
+## AGENTS
+
+Load from \`~/.prjct-cli/projects/${this.projectId}/agents/\`:
+
+**Workflow**: ${workflowAgents.join(", ")}
+**Domain**: ${domainAgents.join(", ") || "none"}
+`;
+        await fs27.writeFile(path28.join(contextPath, "CLAUDE.md"), content, "utf-8");
+      }
+      async generateNowMd(contextPath) {
+        let currentTask = null;
+        try {
+          const statePath = path28.join(this.globalPath, "storage", "state.json");
+          const state = JSON.parse(await fs27.readFile(statePath, "utf-8"));
+          currentTask = state.currentTask;
+        } catch {
+        }
+        const content = currentTask ? `# NOW
+
+**${currentTask.description}**
+
+Started: ${currentTask.startedAt}
+${currentTask.branch ? `Branch: ${currentTask.branch.name}` : ""}
+` : `# NOW
+
+_No active task_
+
+Use \`p. task "description"\` to start working.
+`;
+        await fs27.writeFile(path28.join(contextPath, "now.md"), content, "utf-8");
+      }
+      async generateNextMd(contextPath) {
+        let queue = { tasks: [] };
+        try {
+          const queuePath = path28.join(this.globalPath, "storage", "queue.json");
+          queue = JSON.parse(await fs27.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 fs27.writeFile(path28.join(contextPath, "next.md"), content, "utf-8");
+      }
+      async generateIdeasMd(contextPath) {
+        let ideas = { ideas: [] };
+        try {
+          const ideasPath = path28.join(this.globalPath, "storage", "ideas.json");
+          ideas = JSON.parse(await fs27.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 fs27.writeFile(path28.join(contextPath, "ideas.md"), content, "utf-8");
+      }
+      async generateShippedMd(contextPath) {
+        let shipped = {
+          shipped: []
+        };
+        try {
+          const shippedPath = path28.join(this.globalPath, "storage", "shipped.json");
+          shipped = JSON.parse(await fs27.readFile(shippedPath, "utf-8"));
+        } catch {
+        }
+        const content = `# SHIPPED \u{1F680}
+
+${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.name}**${s.version ? ` v${s.version}` : ""} - ${s.shippedAt}`).join("\n") : "_Nothing shipped yet_"}
+
+**Total shipped:** ${shipped.shipped.length}
+`;
+        await fs27.writeFile(path28.join(contextPath, "shipped.md"), content, "utf-8");
+      }
+      // ==========================================================================
+      // PROJECT.JSON UPDATE
+      // ==========================================================================
+      async updateProjectJson(git, stats) {
+        const projectJsonPath = path28.join(this.globalPath, "project.json");
+        let existing = {};
+        try {
+          existing = JSON.parse(await fs27.readFile(projectJsonPath, "utf-8"));
+        } catch {
+        }
+        const updated = {
+          ...existing,
+          projectId: this.projectId,
+          repoPath: this.projectPath,
+          name: stats.name,
+          version: stats.version,
+          cliVersion: this.cliVersion,
+          techStack: stats.frameworks,
+          fileCount: stats.fileCount,
+          commitCount: git.commits,
+          stack: stats.ecosystem,
+          currentBranch: git.branch,
+          hasUncommittedChanges: git.hasChanges,
+          createdAt: existing.createdAt || date_helper_default.getTimestamp(),
+          lastSync: date_helper_default.getTimestamp()
+        };
+        await fs27.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+      }
+      // ==========================================================================
+      // STATE.JSON UPDATE
+      // ==========================================================================
+      async updateStateJson(stats, stack) {
+        const statePath = path28.join(this.globalPath, "storage", "state.json");
+        let state = {};
+        try {
+          state = JSON.parse(await fs27.readFile(statePath, "utf-8"));
+        } catch {
+        }
+        state.projectId = this.projectId;
+        state.stack = {
+          language: stats.languages[0] || "Unknown",
+          framework: stats.frameworks[0] || null
+        };
+        state.domains = {
+          hasFrontend: stack.hasFrontend,
+          hasBackend: stack.hasBackend,
+          hasDatabase: stack.hasDatabase,
+          hasTesting: stack.hasTesting,
+          hasDocker: stack.hasDocker
+        };
+        state.projectType = stats.projectType;
+        state.metrics = {
+          totalFiles: stats.fileCount
+        };
+        state.lastSync = date_helper_default.getTimestamp();
+        state.lastUpdated = date_helper_default.getTimestamp();
+        state.context = {
+          ...state.context || {},
+          lastSession: date_helper_default.getTimestamp(),
+          lastAction: "Synced project",
+          nextAction: 'Run `p. task "description"` to start working'
+        };
+        await fs27.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+      }
+      // ==========================================================================
+      // MEMORY LOGGING
+      // ==========================================================================
+      async logToMemory(git, stats) {
+        const memoryPath = path28.join(this.globalPath, "memory", "events.jsonl");
+        const event = {
+          ts: date_helper_default.getTimestamp(),
+          action: "sync",
+          branch: git.branch,
+          uncommitted: git.hasChanges,
+          fileCount: stats.fileCount,
+          commitCount: git.commits
+        };
+        await fs27.appendFile(memoryPath, JSON.stringify(event) + "\n", "utf-8");
+      }
+      // ==========================================================================
+      // HELPERS
+      // ==========================================================================
+      async fileExists(filename) {
+        try {
+          await fs27.access(path28.join(this.projectPath, filename));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async getCliVersion() {
+        try {
+          const pkgPath = path28.join(__dirname, "..", "..", "package.json");
+          const pkg = JSON.parse(await fs27.readFile(pkgPath, "utf-8"));
+          return pkg.version || "0.0.0";
+        } catch {
+          return "0.0.0";
+        }
+      }
+      // Empty data structures for error cases
+      emptyGitData() {
+        return {
+          branch: "main",
+          commits: 0,
+          contributors: 0,
+          hasChanges: false,
+          stagedFiles: [],
+          modifiedFiles: [],
+          untrackedFiles: [],
+          recentCommits: [],
+          weeklyCommits: 0
+        };
+      }
+      emptyStats() {
+        return {
+          fileCount: 0,
+          version: "0.0.0",
+          name: "unknown",
+          ecosystem: "unknown",
+          projectType: "simple",
+          languages: [],
+          frameworks: []
+        };
+      }
+      emptyCommands() {
+        return {
+          install: "npm install",
+          run: "npm run",
+          test: "npm test",
+          build: "npm run build",
+          dev: "npm run dev",
+          lint: "npm run lint",
+          format: "npm run format"
+        };
+      }
+      emptyStack() {
+        return {
+          hasFrontend: false,
+          hasBackend: false,
+          hasDatabase: false,
+          hasDocker: false,
+          hasTesting: false,
+          frontendType: null,
+          frameworks: []
+        };
+      }
+    };
+    syncService = new SyncService();
+  }
+});
+
 // core/services/index.ts
 var init_services = __esm({
   "core/services/index.ts"() {
@@ -11384,6 +12197,7 @@ var init_services = __esm({
     init_project_service();
     init_memory_service();
     init_breakdown_service();
+    init_sync_service();
   }
 });
 
@@ -11455,8 +12269,8 @@ var init_base = __esm({
       _detectBugSeverity(description) {
         return breakdownService.detectBugSeverity(description);
       }
-      async _assignAgentForTask(task, projectPath, context) {
-        return agentService.assignForTask(task, projectPath, context);
+      async _assignAgentForTask(task, projectPath, context2) {
+        return agentService.assignForTask(task, projectPath, context2);
       }
     };
   }
@@ -11670,18 +12484,18 @@ var init_workflow = __esm({
 });
 
 // core/utils/project-commands.ts
-import path28 from "path";
+import path29 from "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(path28.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path28.join(projectPath, "yarn.lock"))) return "yarn";
-  if (await fileExists(path28.join(projectPath, "bun.lockb"))) return "bun";
-  if (await fileExists(path28.join(projectPath, "bun.lock"))) return "bun";
-  if (await fileExists(path28.join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(path29.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path29.join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(path29.join(projectPath, "bun.lockb"))) return "bun";
+  if (await fileExists(path29.join(projectPath, "bun.lock"))) return "bun";
+  if (await fileExists(path29.join(projectPath, "package-lock.json"))) return "npm";
   return "npm";
 }
 function pmRun(pm, scriptName) {
@@ -11697,7 +12511,7 @@ function pmTest(pm) {
   return "npm test";
 }
 async function detectProjectCommands(projectPath) {
-  const pkgPath = path28.join(projectPath, "package.json");
+  const pkgPath = path29.join(projectPath, "package.json");
   const pkg = await readJson(pkgPath, null);
   if (pkg) {
     const pm = await detectPackageManager(projectPath, pkg);
@@ -11714,27 +12528,27 @@ async function detectProjectCommands(projectPath) {
     }
     return result;
   }
-  if (await fileExists(path28.join(projectPath, "pytest.ini"))) {
+  if (await fileExists(path29.join(projectPath, "pytest.ini"))) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  const pyproject = await readFile(path28.join(projectPath, "pyproject.toml"), "");
+  const pyproject = await readFile(path29.join(projectPath, "pyproject.toml"), "");
   if (pyproject.includes("[tool.pytest") || pyproject.includes("pytest")) {
     return { stack: "python", test: { tool: "pytest", command: "pytest" } };
   }
-  if (await fileExists(path28.join(projectPath, "Cargo.toml"))) {
+  if (await fileExists(path29.join(projectPath, "Cargo.toml"))) {
     return { stack: "rust", test: { tool: "cargo", command: "cargo test" } };
   }
-  if (await fileExists(path28.join(projectPath, "go.mod"))) {
+  if (await fileExists(path29.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(path28.join(projectPath, "pom.xml"))) {
+  if (await fileExists(path29.join(projectPath, "pom.xml"))) {
     return { stack: "java", test: { tool: "maven", command: "mvn test" } };
   }
-  if (await fileExists(path28.join(projectPath, "gradlew")) && (await fileExists(path28.join(projectPath, "build.gradle")) || await fileExists(path28.join(projectPath, "build.gradle.kts")))) {
+  if (await fileExists(path29.join(projectPath, "gradlew")) && (await fileExists(path29.join(projectPath, "build.gradle")) || await fileExists(path29.join(projectPath, "build.gradle.kts")))) {
     return { stack: "java", test: { tool: "gradle", command: "./gradlew test" } };
   }
   return { stack: "unknown" };
@@ -11751,7 +12565,7 @@ var init_project_commands = __esm({
 });
 
 // core/commands/shipping.ts
-import path29 from "path";
+import path30 from "path";
 var ShippingCommands;
 var init_shipping = __esm({
   "core/commands/shipping.ts"() {
@@ -11880,7 +12694,7 @@ ${result.stderr}`.trim();
        */
       async _bumpVersion(projectPath) {
         try {
-          const pkgPath = path29.join(projectPath, "package.json");
+          const pkgPath = path30.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);
@@ -11902,7 +12716,7 @@ ${result.stderr}`.trim();
        */
       async _updateChangelog(feature, version, projectPath) {
         try {
-          const changelogPath = path29.join(projectPath, "CHANGELOG.md");
+          const changelogPath = path30.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())}
 
@@ -12026,11 +12840,11 @@ var init_registry = __esm({
         if (typeof method !== "function") {
           throw new Error(`${String(methodName)} is not a function`);
         }
-        const wrapper = /* @__PURE__ */ __name(async (params, context) => {
+        const wrapper = /* @__PURE__ */ __name(async (params, context2) => {
           if (params !== void 0 && params !== null) {
-            return method.call(instance2, params, context.projectPath);
+            return method.call(instance2, params, context2.projectPath);
           }
-          return method.call(instance2, context.projectPath);
+          return method.call(instance2, context2.projectPath);
         }, "wrapper");
         this.handlerFns.set(name, wrapper);
         this.setMeta(name, meta);
@@ -12222,9 +13036,9 @@ var init_registry = __esm({
        */
       async execute(name, params, projectPath = process.cwd()) {
         const meta = this.metadata.get(name);
-        let context;
+        let context2;
         if (meta?.requiresProject === false) {
-          context = {
+          context2 = {
             projectId: "",
             projectPath,
             globalPath: "",
@@ -12232,7 +13046,7 @@ var init_registry = __esm({
           };
         } else {
           try {
-            context = await this.buildContext(projectPath);
+            context2 = await this.buildContext(projectPath);
           } catch (error) {
             return {
               success: false,
@@ -12242,11 +13056,11 @@ var init_registry = __esm({
         }
         const handler = this.handlers.get(name);
         if (handler) {
-          return handler.execute(params, context);
+          return handler.execute(params, context2);
         }
         const handlerFn = this.handlerFns.get(name);
         if (handlerFn) {
-          return handlerFn(params, context);
+          return handlerFn(params, context2);
         }
         return {
           success: false,
@@ -12260,23 +13074,23 @@ var init_registry = __esm({
       async executeWithoutProject(name, params, projectPath = process.cwd()) {
         const handler = this.handlers.get(name);
         if (handler) {
-          const context = {
+          const context2 = {
             projectId: "",
             projectPath,
             globalPath: "",
             timestamp: getTimestamp()
           };
-          return handler.execute(params, context);
+          return handler.execute(params, context2);
         }
         const handlerFn = this.handlerFns.get(name);
         if (handlerFn) {
-          const context = {
+          const context2 = {
             projectId: "",
             projectPath,
             globalPath: "",
             timestamp: getTimestamp()
           };
-          return handlerFn(params, context);
+          return handlerFn(params, context2);
         }
         return {
           success: false,
@@ -12298,7 +13112,7 @@ var init_registry = __esm({
 });
 
 // core/commands/analytics.ts
-import path30 from "path";
+import path31 from "path";
 var AnalyticsCommands;
 var init_analytics = __esm({
   "core/commands/analytics.ts"() {
@@ -12323,7 +13137,7 @@ var init_analytics = __esm({
             output_default.fail("no project ID");
             return { success: false, error: "No project ID found" };
           }
-          const projectName = path30.basename(projectPath);
+          const projectName = path31.basename(projectPath);
           const currentTask = await stateStorage.getCurrentTask(projectId);
           const queueTasks = await queueStorage.getActiveTasks(projectId);
           const shipped = await shippedStorage.getRecent(projectId, 5);
@@ -12366,8 +13180,8 @@ var init_analytics = __esm({
             return { success: true, view, metrics };
           }
           if (view === "roadmap") {
-            const context = await context_builder_default.build(projectPath);
-            const roadmapContent = await tool_registry_default.get("Read")(context.paths.roadmap);
+            const context2 = await context_builder_default.build(projectPath);
+            const roadmapContent = await tool_registry_default.get("Read")(context2.paths.roadmap);
             console.log(`
 \u{1F5FA}\uFE0F  ROADMAP - ${projectName}
 `);
@@ -12561,7 +13375,7 @@ ${catInfo?.title || cat}:`);
 });
 
 // core/commands/cleanup.ts
-import path31 from "path";
+import path32 from "path";
 async function cleanupMemory(projectPath) {
   const projectId = await config_manager_default.getProjectId(projectPath);
   const results = { rotated: [], totalSize: 0, freedSpace: 0 };
@@ -12577,7 +13391,7 @@ async function cleanupMemory(projectPath) {
         results.totalSize += sizeMB;
         const rotated = await jsonl_helper_default.rotateJsonLinesIfNeeded(filePath, 10);
         if (rotated) {
-          results.rotated.push(path31.basename(filePath));
+          results.rotated.push(path32.basename(filePath));
           results.freedSpace += sizeMB;
         }
       }
@@ -12684,7 +13498,7 @@ var init_cleanup = __esm({
 });
 
 // core/commands/design.ts
-import path32 from "path";
+import path33 from "path";
 async function design(target = null, options = {}, projectPath = process.cwd()) {
   try {
     const designType = options.type || "architecture";
@@ -12696,7 +13510,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 = path32.join(
+    const designsPath = path33.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "planning",
       "designs"
@@ -12736,7 +13550,7 @@ async function design(target = null, options = {}, projectPath = process.cwd())
         break;
     }
     const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const designFilePath = path32.join(designsPath, designFileName);
+    const designFilePath = path33.join(designsPath, designFileName);
     await file_helper_exports.writeFile(designFilePath, designContent);
     await memoryService.log(projectPath, "design_created", {
       type: designType,
@@ -12760,7 +13574,7 @@ var init_design = __esm({
 });
 
 // core/commands/snapshots.ts
-import path33 from "path";
+import path34 from "path";
 async function recover(projectPath = process.cwd()) {
   try {
     const projectId = await config_manager_default.getProjectId(projectPath);
@@ -12812,7 +13626,7 @@ async function undo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path33.join(
+    const snapshotsPath = path34.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
@@ -12833,7 +13647,7 @@ async function undo(projectPath = process.cwd()) {
         cwd: projectPath,
         encoding: "utf-8"
       });
-      const snapshotFile = path33.join(snapshotsPath, "history.json");
+      const snapshotFile = path34.join(snapshotsPath, "history.json");
       let history2 = { snapshots: [], current: -1 };
       try {
         const content = await file_helper_exports.readFile(snapshotFile);
@@ -12873,11 +13687,11 @@ async function redo(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path33.join(
+    const snapshotsPath = path34.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path33.join(snapshotsPath, "history.json");
+    const snapshotFile = path34.join(snapshotsPath, "history.json");
     let history2;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -12936,11 +13750,11 @@ async function history(projectPath = process.cwd()) {
       output_default.fail("no project ID");
       return { success: false, error: "No project ID found" };
     }
-    const snapshotsPath = path33.join(
+    const snapshotsPath = path34.join(
       path_manager_default.getGlobalProjectPath(projectId),
       "snapshots"
     );
-    const snapshotFile = path33.join(snapshotsPath, "history.json");
+    const snapshotFile = path34.join(snapshotsPath, "history.json");
     let snapshotHistory;
     try {
       const content = await file_helper_exports.readFile(snapshotFile);
@@ -13046,8 +13860,8 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import path34 from "path";
-import fs27 from "fs";
+import path35 from "path";
+import fs28 from "fs";
 import chalk4 from "chalk";
 var SetupCommands;
 var init_setup2 = __esm({
@@ -13157,7 +13971,7 @@ var init_setup2 = __esm({
         try {
           const claudeDir = path_manager_default.getClaudeDir();
           const settingsPath = path_manager_default.getClaudeSettingsPath();
-          const statusLinePath = path34.join(claudeDir, "prjct-statusline.sh");
+          const statusLinePath = path35.join(claudeDir, "prjct-statusline.sh");
           const scriptContent = `#!/bin/bash
 # prjct Status Line for Claude Code
 # Shows version update notifications and current task
@@ -13215,11 +14029,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          fs27.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
+          fs28.writeFileSync(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
-          if (fs27.existsSync(settingsPath)) {
+          if (fs28.existsSync(settingsPath)) {
             try {
-              settings = JSON.parse(fs27.readFileSync(settingsPath, "utf8"));
+              settings = JSON.parse(fs28.readFileSync(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -13227,7 +14041,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          fs27.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          fs28.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: error.message };
@@ -13274,18 +14088,155 @@ echo "\u26A1 prjct"
         console.log(chalk4.bold.magenta("Happy shipping! \u{1F680}"));
         console.log("");
       }
+    };
+  }
+});
+
+// core/commands/context.ts
+import fs29 from "fs/promises";
+import path36 from "path";
+var ContextCommands, contextCommands;
+var init_context = __esm({
+  "core/commands/context.ts"() {
+    "use strict";
+    init_config_manager();
+    init_path_manager();
+    init_storage2();
+    init_orchestrator_executor();
+    init_fs();
+    ContextCommands = class {
+      static {
+        __name(this, "ContextCommands");
+      }
       /**
-       * Migrate all projects to UUID format
+       * Get full project context for Claude
+       *
+       * Usage:
+       *   prjct context task "add user auth"
+       *   prjct context done
+       *   prjct context ship
+       *
+       * Returns JSON with all orchestrator data.
        */
-      async migrateAll(_options = {}) {
-        console.log("\u{1F504} Migrating all projects to UUID format...\n");
-        console.log("\u2705 Migration complete (no projects needed migration)\n");
-        return {
-          success: true,
-          message: "Migration complete"
-        };
+      async context(input = null, projectPath = process.cwd()) {
+        try {
+          const parts = (input || "").trim().split(/\s+/);
+          const command = parts[0] || "task";
+          const taskDescription = parts.slice(1).join(" ");
+          const config = await config_manager_default.readConfig(projectPath);
+          if (!config || !config.projectId) {
+            const output2 = {
+              projectId: "",
+              globalPath: "",
+              currentTask: null,
+              domains: [],
+              primaryDomain: null,
+              agents: [],
+              subtasks: null,
+              repoAnalysis: {
+                ecosystem: "unknown",
+                frameworks: [],
+                hasTests: false,
+                technologies: []
+              }
+            };
+            console.log(JSON.stringify(output2, null, 2));
+            return {
+              success: false,
+              message: "No prjct project. Run `p. init` first."
+            };
+          }
+          const projectId = config.projectId;
+          const globalPath = path_manager_default.getGlobalProjectPath(projectId);
+          const state = await stateStorage.read(projectId);
+          const currentTask = state?.currentTask ? {
+            id: state.currentTask.id,
+            description: state.currentTask.description,
+            type: state.currentTask.type || "task",
+            status: state.currentTask.status || "active",
+            branch: state.currentTask.branch,
+            subtasks: state.currentTask.subtasks?.map((st) => ({
+              id: st.id,
+              description: st.description,
+              status: st.status || "pending"
+            })),
+            currentSubtaskIndex: state.currentTask.currentSubtaskIndex
+          } : null;
+          let orchestratorContext = null;
+          if (taskDescription) {
+            try {
+              orchestratorContext = await orchestrator_executor_default.execute(
+                command,
+                taskDescription,
+                projectPath
+              );
+            } catch (error) {
+              console.error(`Warning: Orchestrator failed: ${error.message}`);
+            }
+          }
+          const repoAnalysis = await this.loadRepoAnalysis(globalPath);
+          const output = {
+            projectId,
+            globalPath,
+            currentTask,
+            domains: orchestratorContext?.detectedDomains || [],
+            primaryDomain: orchestratorContext?.primaryDomain || null,
+            agents: orchestratorContext?.agents.map((a) => ({
+              name: a.name,
+              domain: a.domain,
+              filePath: a.filePath,
+              skills: a.skills,
+              preview: a.content.substring(0, 500)
+            })) || [],
+            subtasks: orchestratorContext?.subtasks?.map((st) => ({
+              id: st.id,
+              description: st.description,
+              domain: st.domain,
+              agent: st.agent,
+              status: st.status,
+              order: st.order
+            })) || null,
+            repoAnalysis: {
+              ecosystem: repoAnalysis?.ecosystem || "unknown",
+              frameworks: repoAnalysis?.frameworks || [],
+              hasTests: repoAnalysis?.hasTests || false,
+              technologies: repoAnalysis?.technologies || []
+            }
+          };
+          console.log(JSON.stringify(output, null, 2));
+          return {
+            success: true,
+            message: ""
+            // Empty message - JSON output is the result
+          };
+        } catch (error) {
+          return {
+            success: false,
+            message: `Context error: ${error.message}`
+          };
+        }
+      }
+      /**
+       * Load repo analysis from analysis/repo-analysis.json
+       */
+      async loadRepoAnalysis(globalPath) {
+        try {
+          const analysisPath = path36.join(globalPath, "analysis", "repo-analysis.json");
+          const content = await fs29.readFile(analysisPath, "utf-8");
+          const data = JSON.parse(content);
+          return {
+            ecosystem: data.ecosystem || "unknown",
+            frameworks: data.frameworks || [],
+            hasTests: data.hasTests ?? false,
+            technologies: data.technologies || []
+          };
+        } catch (error) {
+          if (isNotFoundError(error)) return null;
+          return null;
+        }
       }
     };
+    contextCommands = new ContextCommands();
   }
 });
 
@@ -13301,6 +14252,7 @@ var init_commands = __esm({
     init_maintenance();
     init_analysis2();
     init_setup2();
+    init_context();
     PrjctCommands = class {
       static {
         __name(this, "PrjctCommands");
@@ -13313,6 +14265,7 @@ var init_commands = __esm({
       maintenance;
       analysis;
       setupCmds;
+      contextCmds;
       // Shared state
       agent;
       agentInfo;
@@ -13326,15 +14279,13 @@ var init_commands = __esm({
         this.maintenance = new MaintenanceCommands();
         this.analysis = new AnalysisCommands();
         this.setupCmds = new SetupCommands();
+        this.contextCmds = new ContextCommands();
         this.agent = null;
         this.agentInfo = null;
         this.currentAuthor = null;
         this.prjctDir = ".prjct";
       }
       // ========== Workflow Commands ==========
-      async work(task = null, projectPath = process.cwd()) {
-        return this.workflow.now(task, projectPath);
-      }
       async done(projectPath = process.cwd()) {
         return this.workflow.done(projectPath);
       }
@@ -13351,9 +14302,6 @@ var init_commands = __esm({
       async init(idea = null, projectPath = process.cwd()) {
         return this.planning.init(idea, projectPath);
       }
-      async feature(description, projectPath = process.cwd()) {
-        return this.planning.feature(description, projectPath);
-      }
       async bug(description, projectPath = process.cwd()) {
         return this.planning.bug(description, projectPath);
       }
@@ -13400,6 +14348,10 @@ var init_commands = __esm({
       async sync(projectPath = process.cwd()) {
         return this.analysis.sync(projectPath);
       }
+      // ========== Context Commands ==========
+      async context(input = null, projectPath = process.cwd()) {
+        return this.contextCmds.context(input, projectPath);
+      }
       // ========== Setup Commands ==========
       async start() {
         return this.setupCmds.start();
@@ -13407,9 +14359,6 @@ var init_commands = __esm({
       async setup(options = {}) {
         return this.setupCmds.setup(options);
       }
-      async migrateAll(options = {}) {
-        return this.setupCmds.migrateAll(options);
-      }
       async installStatusLine() {
         return this.setupCmds.installStatusLine();
       }
@@ -13494,17 +14443,6 @@ var init_command_data = __esm({
         requiresProject: true,
         features: ["Agentic type classification", "7-phase workflow", "Git branch management", "Task breakdown"]
       },
-      {
-        name: "feature",
-        group: "core",
-        description: "DEPRECATED - Use /p:task instead",
-        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
-        params: "<description>",
-        implemented: true,
-        hasTemplate: true,
-        requiresProject: true,
-        deprecated: true
-      },
       {
         name: "spec",
         group: "core",
@@ -13515,28 +14453,6 @@ var init_command_data = __esm({
         hasTemplate: true,
         requiresProject: true
       },
-      {
-        name: "now",
-        group: "core",
-        description: "DEPRECATED - Use /p:task instead",
-        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
-        params: "[task]",
-        implemented: true,
-        hasTemplate: true,
-        requiresProject: true,
-        deprecated: true
-      },
-      {
-        name: "work",
-        group: "core",
-        description: "DEPRECATED - Use /p:task instead",
-        usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
-        params: "[task]",
-        implemented: true,
-        hasTemplate: true,
-        requiresProject: true,
-        deprecated: true
-      },
       {
         name: "pause",
         group: "core",
@@ -13758,16 +14674,6 @@ var init_command_data = __esm({
         hasTemplate: true,
         requiresProject: true
       },
-      {
-        name: "migrate-all",
-        group: "setup",
-        description: "Migrate all legacy projects to UUID format",
-        usage: { claude: "/p:migrate-all", terminal: "prjct migrate-all" },
-        params: "[--deep-scan] [--dry-run]",
-        implemented: true,
-        hasTemplate: true,
-        requiresProject: false
-      },
       {
         name: "auth",
         group: "setup",
@@ -13777,6 +14683,17 @@ var init_command_data = __esm({
         implemented: true,
         hasTemplate: true,
         requiresProject: false
+      },
+      {
+        name: "context",
+        group: "setup",
+        description: "Get project context as JSON for Claude templates",
+        usage: { claude: null, terminal: "prjct context <command> [args]" },
+        params: "<command> [args]",
+        implemented: true,
+        hasTemplate: false,
+        requiresProject: true,
+        features: ["Returns JSON with project context", "Runs orchestrator", "Loads agents and skills"]
       }
     ];
   }
@@ -13792,14 +14709,11 @@ function registerAllCommands() {
   if (commandRegistry.has("work")) return;
   registerCategories();
   const getMeta = /* @__PURE__ */ __name((name) => COMMANDS.find((c) => c.name === name), "getMeta");
-  commandRegistry.registerMethod("work", workflow, "now", getMeta("work"));
-  commandRegistry.registerMethod("now", workflow, "now", getMeta("now"));
   commandRegistry.registerMethod("done", workflow, "done", getMeta("done"));
   commandRegistry.registerMethod("next", workflow, "next", getMeta("next"));
   commandRegistry.registerMethod("pause", workflow, "pause", getMeta("pause"));
   commandRegistry.registerMethod("resume", workflow, "resume", getMeta("resume"));
   commandRegistry.registerMethod("init", planning, "init", getMeta("init"));
-  commandRegistry.registerMethod("feature", planning, "feature", getMeta("feature"));
   commandRegistry.registerMethod("bug", planning, "bug", getMeta("bug"));
   commandRegistry.registerMethod("idea", planning, "idea", getMeta("idea"));
   commandRegistry.registerMethod("spec", planning, "spec", getMeta("spec"));
@@ -13816,9 +14730,9 @@ function registerAllCommands() {
   commandRegistry.registerMethod("sync", analysis, "sync", getMeta("sync"));
   commandRegistry.registerMethod("start", setup, "start", getMeta("start"));
   commandRegistry.registerMethod("setup", setup, "setup", getMeta("setup"));
-  commandRegistry.registerMethod("migrateAll", setup, "migrateAll", getMeta("migrate-all"));
+  commandRegistry.registerMethod("context", context, "context", getMeta("context"));
 }
-var workflow, planning, shipping, analytics, maintenance, analysis, setup;
+var workflow, planning, shipping, analytics, maintenance, analysis, setup, context;
 var init_register = __esm({
   "core/commands/register.ts"() {
     "use strict";
@@ -13831,6 +14745,7 @@ var init_register = __esm({
     init_maintenance();
     init_analysis2();
     init_setup2();
+    init_context();
     workflow = new WorkflowCommands();
     planning = new PlanningCommands();
     shipping = new ShippingCommands();
@@ -13838,6 +14753,7 @@ var init_register = __esm({
     maintenance = new MaintenanceCommands();
     analysis = new AnalysisCommands();
     setup = new SetupCommands();
+    context = new ContextCommands();
     __name(registerCategories, "registerCategories");
     __name(registerAllCommands, "registerAllCommands");
     registerAllCommands();
@@ -13860,22 +14776,18 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.35.2",
+      version: "0.35.3",
       description: "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
       main: "core/index.ts",
       bin: {
         prjct: "bin/prjct"
       },
-      workspaces: [
-        "packages/*"
-      ],
       publishConfig: {
         access: "public",
         registry: "https://registry.npmjs.org"
       },
       scripts: {
         build: "node scripts/build.js",
-        "build:shared": "bun run --filter '@prjct/shared' build",
         "build:node": "node scripts/build.js",
         release: "node scripts/release.js",
         "release:patch": "node scripts/release.js patch",
@@ -13951,15 +14863,13 @@ var require_package = __commonJS({
         "bin/",
         "core/",
         "dist/",
-        "packages/shared/",
         "templates/",
         "scripts/postinstall.js",
         "scripts/build.js",
         "scripts/install.sh",
         "LICENSE",
         "README.md",
-        "CHANGELOG.md",
-        "CLAUDE.md"
+        "CHANGELOG.md"
       ],
       trustedDependencies: [
         "chalk",
@@ -14020,20 +14930,16 @@ Use 'prjct --help' to see available commands.`);
       result = await commands.cleanup(options);
     } else if (commandName === "setup") {
       result = await commands.setup(options);
-    } else if (commandName === "migrate-all") {
-      result = await commands.migrateAll(options);
     } else {
       const param = parsedArgs.join(" ") || null;
       const standardCommands = {
         // Core workflow
-        work: /* @__PURE__ */ __name((p) => commands.work(p), "work"),
         done: /* @__PURE__ */ __name(() => commands.done(), "done"),
         next: /* @__PURE__ */ __name(() => commands.next(), "next"),
         pause: /* @__PURE__ */ __name((p) => commands.pause(p || ""), "pause"),
         resume: /* @__PURE__ */ __name((p) => commands.resume(p), "resume"),
         // Planning
         init: /* @__PURE__ */ __name((p) => commands.init(p), "init"),
-        feature: /* @__PURE__ */ __name((p) => commands.feature(p || ""), "feature"),
         bug: /* @__PURE__ */ __name((p) => commands.bug(p || ""), "bug"),
         idea: /* @__PURE__ */ __name((p) => commands.idea(p || ""), "idea"),
         spec: /* @__PURE__ */ __name((p) => commands.spec(p), "spec"),
@@ -14048,7 +14954,9 @@ Use 'prjct --help' to see available commands.`);
         history: /* @__PURE__ */ __name(() => commands.history(), "history"),
         // Setup
         sync: /* @__PURE__ */ __name(() => commands.sync(), "sync"),
-        start: /* @__PURE__ */ __name(() => commands.start(), "start")
+        start: /* @__PURE__ */ __name(() => commands.start(), "start"),
+        // Context (for Claude templates)
+        context: /* @__PURE__ */ __name((p) => commands.context(p), "context")
       };
       const handler = standardCommands[commandName];
       if (handler) {