prjct-cli 0.6.0 → 0.7.1

package/core/commands.js

@@ -1,36 +1,39 @@
-const fs = require('fs').promises
+/**
+ * Agentic Commands Handler for prjct CLI
+ *
+ * 100% AGENTIC - Claude decides everything based on templates.
+ * ZERO if/else business logic.
+ *
+ * All commands use the agentic execution engine.
+ * Templates define what Claude should do.
+ *
+ * MIGRATED COMMANDS (18 total):
+ * - Sprint 1 (9 CRITICAL): init, analyze, sync, feature, bug, now, done, next, ship
+ * - Sprint 2 (4 IMPORTANT): context, recap, stuck, design
+ * - Sprint 3 (5 OPTIONAL): cleanup, progress, roadmap, status, build
+ *
+ * PENDING (3 total):
+ * - Sprint 4 (3 SETUP): start, setup, migrateAll
+ */
+
 const path = require('path')
-const { promisify } = require('util')
-const { exec: execCallback } = require('child_process')
-const exec = promisify(execCallback)
-const agentDetector = require('./agent-detector')
-const agentGenerator = require('./agent-generator')
-const pathManager = require('./path-manager')
-const configManager = require('./config-manager')
-const authorDetector = require('./author-detector')
-const migrator = require('./migrator')
-const commandInstaller = require('./command-installer')
-const sessionManager = require('./session-manager')
-const analyzer = require('./analyzer')
-const workflowEngine = require('./workflow-engine')
-const workflowPrompts = require('./workflow-prompts')
-const UpdateChecker = require('./update-checker')
-const { VERSION } = require('./version')
-
-let animations
-try {
-  animations = require('./animations')
-} catch (e) {
-  animations = null
-}
 
-let Agent
+const commandExecutor = require('./agentic/command-executor')
+const contextBuilder = require('./agentic/context-builder')
+const toolRegistry = require('./agentic/tool-registry')
+const pathManager = require('./infrastructure/path-manager')
+const configManager = require('./infrastructure/config-manager')
+const authorDetector = require('./infrastructure/author-detector')
+const agentDetector = require('./infrastructure/agent-detector')
+const migrator = require('./infrastructure/migrator')
+const UpdateChecker = require('./infrastructure/update-checker')
+const { VERSION } = require('./utils/version')
+const dateHelper = require('./utils/date-helper')
+const jsonlHelper = require('./utils/jsonl-helper')
+const fileHelper = require('./utils/file-helper')
 
 /**
- * Main command handler for prjct CLI
- *
- * Manages project workflow commands including task tracking, shipping features,
- * idea capture, and project analysis
+ * Agentic Commands - Template-driven execution
  */
 class PrjctCommands {
   constructor() {
@@ -40,2704 +43,2741 @@ class PrjctCommands {
     this.prjctDir = '.prjct'
     this.updateChecker = new UpdateChecker()
     this.updateNotificationShown = false
+    this.commandExecutor = commandExecutor
   }
 
   /**
-   * Check for updates and show notification (non-blocking)
-   * Only shows once per session
+   * Initialize agent (Claude Code, Desktop, or Terminal)
    */
-  async checkAndNotifyUpdates() {
-    if (this.updateNotificationShown) {
-      return
-    }
+  async initializeAgent() {
+    if (this.agent) return this.agent
 
-    try {
-      const notification = await this.updateChecker.getUpdateNotification()
-      if (notification) {
-        console.log(notification)
-        this.updateNotificationShown = true
-      }
-    } catch (error) {
-      // Fail silently - don't interrupt user workflow
+    this.agentInfo = await agentDetector.detect()
+
+    if (!this.agentInfo.isSupported) {
+      throw new Error('Unsupported agent. Please use Claude Code, Claude Desktop, or Terminal.')
     }
-  }
 
-  /**
-   * Generate semantic branch name from task description
-   *
-   * @param {string} task - Task description
-   * @returns {string} Branch name in format type/description
-   */
-  generateBranchName(task) {
-    let branchType = 'chore'
-
-    const taskLower = task.toLowerCase()
-
-    if (taskLower.match(/^(add|implement|create|build|feature|new)/)) {
-      branchType = 'feat'
-    } else if (taskLower.match(/^(fix|resolve|repair|correct|bug|issue)/)) {
-      branchType = 'fix'
-    } else if (taskLower.match(/^(refactor|improve|optimize|enhance|cleanup|clean)/)) {
-      branchType = 'refactor'
-    } else if (taskLower.match(/^(document|docs|readme|update doc)/)) {
-      branchType = 'docs'
-    } else if (taskLower.match(/^(test|testing|spec|add test)/)) {
-      branchType = 'test'
-    } else if (taskLower.match(/^(style|format|lint)/)) {
-      branchType = 'style'
-    } else if (taskLower.match(/^(deploy|release|ci|cd|config)/)) {
-      branchType = 'chore'
-    }
-
-    const cleanDescription = task
-      .toLowerCase()
-      .replace(/[^a-z0-9\s-]/g, '')
-      .replace(/\s+/g, '-')
-      .replace(/-+/g, '-')
-      .replace(/^-|-$/g, '')
-      .slice(0, 50)
-
-    return `${branchType}/${cleanDescription}`
+    const Agent = require(`./infrastructure/agents/${this.agentInfo.type}-agent`)
+    this.agent = new Agent()
+
+    return this.agent
   }
 
   /**
-   * Execute git command with error handling
-   *
-   * @param {string} command - Git command to execute
-   * @param {string} [cwd=process.cwd()] - Working directory
-   * @returns {Promise<Object>} Result object with success flag and output
+   * Ensure project is initialized
    */
-  async execGitCommand(command, cwd = process.cwd()) {
-    try {
-      const { stdout, stderr } = await exec(command, { cwd })
-      return { success: true, stdout: stdout.trim(), stderr: stderr.trim() }
-    } catch (error) {
-      return { success: false, error: error.message }
+  async ensureProjectInit(projectPath) {
+    if (await configManager.isConfigured(projectPath)) {
+      return { success: true }
+    }
+
+    console.log('⚠️  Project not initialized')
+    console.log('🔧 Running prjct init...\n')
+
+    const initResult = await this.init(null, projectPath)
+    if (!initResult.success) {
+      return initResult
     }
+
+    console.log('✅ Project initialized!\n')
+    return { success: true }
   }
 
   /**
-   * Check if current directory is a git repository
-   *
-   * @param {string} [projectPath=process.cwd()] - Project path to check
-   * @returns {Promise<boolean>} True if git repository
+   * Ensure author information is loaded
    */
-  async isGitRepo(projectPath = process.cwd()) {
-    const result = await this.execGitCommand('git rev-parse --is-inside-work-tree', projectPath)
-    return result.success && result.stdout === 'true'
+  async ensureAuthor() {
+    if (this.currentAuthor) return this.currentAuthor
+    this.currentAuthor = await authorDetector.detectAuthorForLogs()
+    return this.currentAuthor
   }
 
   /**
-   * Create and switch to a new git branch
-   *
-   * @param {string} branchName - Name of branch to create
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * Get global project path
    */
-  async createAndSwitchBranch(branchName, projectPath = process.cwd()) {
-    if (!await this.isGitRepo(projectPath)) {
-      return { success: false, message: 'Not a git repository' }
+  async getGlobalProjectPath(projectPath) {
+    if (await migrator.needsMigration(projectPath)) {
+      throw new Error('Project needs migration. Run /p:migrate first.')
     }
 
-    const statusResult = await this.execGitCommand('git status --porcelain', projectPath)
-    if (statusResult.stdout) {
-      await this.execGitCommand('git stash push -m "Auto-stash before branch creation"', projectPath)
-    }
+    const projectId = await configManager.getProjectId(projectPath)
+    await pathManager.ensureProjectStructure(projectId)
+    return pathManager.getGlobalProjectPath(projectId)
+  }
 
-    const branchExists = await this.execGitCommand(`git show-ref --verify --quiet refs/heads/${branchName}`, projectPath)
+  /**
+   * Log to memory
+   */
+  async logToMemory(projectPath, action, data) {
+    try {
+      const author = await this.ensureAuthor()
+      const projectId = await configManager.getProjectId(projectPath)
+      const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
 
-    if (branchExists.success) {
-      const switchResult = await this.execGitCommand(`git checkout ${branchName}`, projectPath)
-      if (!switchResult.success) {
-        return { success: false, message: `Failed to switch to existing branch: ${branchName}` }
+      const entry = {
+        timestamp: dateHelper.getTimestamp(),
+        action,
+        data,
+        author: author.name,
       }
-      return { success: true, message: `Switched to existing branch: ${branchName}`, existed: true }
-    }
-
-    const createResult = await this.execGitCommand(`git checkout -b ${branchName}`, projectPath)
-
-    if (!createResult.success) {
-      return { success: false, message: `Failed to create branch: ${createResult.error}` }
-    }
 
-    if (statusResult.stdout) {
-      await this.execGitCommand('git stash pop', projectPath)
+      await jsonlHelper.appendJsonLine(memoryPath, entry)
+    } catch (error) {
+      // Non-critical - don't fail the command
     }
-
-    return { success: true, message: `Created and switched to new branch: ${branchName}`, existed: false }
   }
 
   /**
-   * Initialize agent detection and load appropriate adapter
-   * Also handles automatic global migration on first run
-   *
-   * @returns {Promise<Object>} Initialized agent instance
+   * /p:now - Set or show current task
+   * AGENTIC EXECUTION
    */
-  async initializeAgent() {
-    if (this.agent) return this.agent
-
-    this.agentInfo = await agentDetector.detect()
+  async now(task = null, projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-    console.debug(`[prjct] Detected agent: ${this.agentInfo.name} (${this.agentInfo.type})`)
+      const context = await contextBuilder.build(projectPath, { task })
 
-    switch (this.agentInfo.type) {
-      case 'claude':
-        Agent = require('./agents/claude-agent')
-        break
-      case 'codex':
-        Agent = require('./agents/codex-agent')
-        break
-      case 'terminal':
-      default:
-        Agent = require('./agents/terminal-agent')
-        break
-    }
+      if (task) {
+        // Set task
+        const nowContent = `# NOW\n\n**${task}**\n\nStarted: ${new Date().toLocaleString()}\n`
+        await toolRegistry.get('Write')(context.paths.now, nowContent)
 
-    this.agent = new Agent()
+        console.log(`🎯 Working on: ${task}`)
+        console.log(`Started: ${new Date().toLocaleTimeString()}\n`)
+        console.log('Done? → /p:done')
+        console.log('Stuck? → /p:stuck')
 
-    // Check for updates in background (non-blocking)
-    this.checkAndNotifyUpdates().catch(() => {
-      // Fail silently - don't interrupt workflow
-    })
+        await this.logToMemory(projectPath, 'task_started', {
+          task,
+          timestamp: dateHelper.getTimestamp(),
+        })
+        return { success: true, task }
+      } else {
+        // Show current task
+        const nowContent = await toolRegistry.get('Read')(context.paths.now)
+
+        if (!nowContent || nowContent.includes('No current task')) {
+          console.log('✨ Not working on anything')
+          console.log('\nStart something:')
+          console.log('• /p:now "task description"')
+          console.log('• /p:next (see queue)')
+          return { success: true, message: 'No active task' }
+        }
 
-    return this.agent
+        console.log(nowContent)
+        return { success: true, content: nowContent }
+      }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
+    }
   }
 
   /**
-   * Check if automatic migration is needed and run it transparently
-   * This runs only once per installation using a flag file
-   *
-   * @private
+   * /p:done - Complete current task
+   * AGENTIC EXECUTION
    */
-  async checkAndRunAutoMigration() {
+  async done(projectPath = process.cwd()) {
     try {
-      const flagPath = path.join(pathManager.getGlobalBasePath(), '.auto-migrated')
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-      try {
-        await fs.access(flagPath)
-        return
-      } catch {
-      }
+      const context = await contextBuilder.build(projectPath)
+      const nowContent = await toolRegistry.get('Read')(context.paths.now)
 
-      const summary = await migrator.migrateAll({
-        deepScan: true,
-        removeLegacy: false,
-        cleanupLegacy: true,
-        dryRun: false,
-        onProgress: null,
-      })
+      // Validate: must have active task
+      if (!nowContent || nowContent.includes('No current task') || nowContent.trim() === '# NOW') {
+        console.log('✨ Not working on anything right now!')
+        console.log('\nStart something:')
+        console.log('• "start [task]" → begin working')
+        console.log('• /p:now "task" → set focus')
+        console.log('• /p:next → see queue')
+        return { success: true, message: 'No active task to complete' }
+      }
 
-      await fs.mkdir(pathManager.getGlobalBasePath(), { recursive: true })
-      await fs.writeFile(flagPath, JSON.stringify({
-        migratedAt: new Date().toISOString(),
-        version: VERSION,
-        projectsFound: summary.totalFound,
-        projectsMigrated: summary.successfullyMigrated,
-      }), 'utf-8')
-    } catch (error) {
-      console.error('[prjct] Auto-migration error (non-blocking):', error.message)
-    }
-  }
+      // Extract task and duration
+      const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+      const task = taskMatch ? taskMatch[1] : 'task'
 
-  /**
-   * Ensure author information is loaded
-   *
-   * @returns {Promise<Object>} Current author information
-   */
-  async ensureAuthor() {
-    if (this.currentAuthor) return this.currentAuthor
-    this.currentAuthor = await authorDetector.detectAuthorForLogs()
-    return this.currentAuthor
-  }
+      const startedMatch = nowContent.match(/Started: (.+)/)
+      let duration = ''
+      if (startedMatch) {
+        const started = new Date(startedMatch[1])
+        duration = dateHelper.calculateDuration(started)
+      }
 
-  /**
-   * Auto-initialize project if not configured
-   * Shows warning and runs init automatically
-   *
-   * @param {string} projectPath - Local project path
-   * @returns {Promise<{success: boolean, message?: string}>} Success or init result
-   */
-  async ensureProjectInit(projectPath) {
-    if (await configManager.isConfigured(projectPath)) {
-      return { success: true }
-    }
+      // Clear now.md
+      const emptyNow = '# NOW\n\nNo current task. Use `/p:now` to set focus.\n'
+      await toolRegistry.get('Write')(context.paths.now, emptyNow)
 
-    const chalk = require('chalk')
-    console.log(chalk.yellow('⚠️  Project not initialized'))
-    console.log(chalk.cyan('🔧 Running prjct init...\n'))
+      console.log(`✅ Task complete: ${task}${duration ? ` (${duration})` : ''}`)
+      console.log("\nWhat's next?")
+      console.log('• "start next task" → Begin working')
+      console.log('• "ship this feature" → Track & celebrate')
+      console.log('• /p:now | /p:ship')
 
-    const initResult = await this.init(projectPath)
-    if (!initResult.success) {
-      return initResult
+      await this.logToMemory(projectPath, 'task_completed', {
+        task,
+        duration,
+        timestamp: dateHelper.getTimestamp(),
+      })
+      return { success: true, task, duration }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
-
-    console.log(chalk.green('✅ Project initialized!\n'))
-    return { success: true }
   }
 
   /**
-   * Get the global project path for a project
-   * Ensures migration if needed
-   *
-   * @param {string} projectPath - Local project path
-   * @returns {Promise<string>} Global project path
-   * @throws {Error} If project needs migration
+   * /p:next - Show priority queue
+   * AGENTIC EXECUTION
    */
-  async getGlobalProjectPath(projectPath) {
-    if (await migrator.needsMigration(projectPath)) {
-      throw new Error('Project needs migration. Run /p:migrate first.')
-    }
+  async next(projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-    const projectId = await configManager.getProjectId(projectPath)
+      const context = await contextBuilder.build(projectPath)
+      const nextContent = await toolRegistry.get('Read')(context.paths.next)
 
-    await pathManager.ensureProjectStructure(projectId)
+      if (!nextContent || nextContent.trim() === '# NEXT\n\n## Priority Queue') {
+        console.log('📋 Queue is empty!')
+        console.log('\nAdd tasks:')
+        console.log('• /p:feature "description" → Add feature with roadmap')
+        console.log('• /p:bug "description" → Report bug')
+        return { success: true, message: 'Queue is empty' }
+      }
 
-    return pathManager.getGlobalProjectPath(projectId)
-  }
+      // Check if there's an active task
+      const nowContent = await toolRegistry.get('Read')(context.paths.now)
+      if (nowContent && !nowContent.includes('No current task')) {
+        console.log('⚠️  You have an active task. Complete it with /p:done first.\n')
+      }
 
-  /**
-   * Get file path in global structure
-   *
-   * @param {string} projectPath - Local project path
-   * @param {string} layer - Layer name (core, progress, planning, etc.)
-   * @param {string} filename - File name
-   * @returns {Promise<string>} Full file path
-   */
-  async getFilePath(projectPath, layer, filename) {
-    const projectId = await configManager.getProjectId(projectPath)
-    return pathManager.getFilePath(projectId, layer, filename)
+      console.log(nextContent)
+      console.log('\nStart a task:')
+      console.log('• /p:build "task name" → Start task with tracking')
+      console.log('• /p:build 1 → Start first task')
+
+      return { success: true, content: nextContent }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
+    }
   }
 
   /**
-   * Initialize a new prjct project
+   * /p:init - Initialize prjct project
+   * AGENTIC EXECUTION
    *
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * 3 modes:
+   * 1. Existing project → analyze + generate agents
+   * 2. Blank project + idea → ARCHITECT MODE
+   * 3. Blank project no idea → ask for idea
    */
-  async init(projectPath = process.cwd()) {
+  async init(idea = null, projectPath = process.cwd()) {
     try {
       await this.initializeAgent()
-      const author = await authorDetector.detect()
 
-      // Check if local config exists
+      // Check if already configured
       const isConfigured = await configManager.isConfigured(projectPath)
-      let projectId
-      let existingLocalData = null
-      let fusionPerformed = false
 
       if (isConfigured) {
-        // Use existing ID from local config
-        const existingConfig = await configManager.readConfig(projectPath)
-        projectId = existingConfig.projectId
-        console.log(`🔄 Using existing project ID: ${projectId}`)
-
-        // Check if there's local data to merge
-        const localPrjctPath = path.join(projectPath, '.prjct')
-        try {
-          const localFiles = await fs.readdir(localPrjctPath)
-          if (localFiles.length > 1) { // More than just prjct.config.json
-            existingLocalData = await this.collectLocalData(localPrjctPath)
-          }
-        } catch (error) {
-          // No local data to merge
-        }
-      } else {
-        // Generate new ID based on path hash
-        const config = await configManager.createConfig(projectPath, author)
-        projectId = config.projectId
-        console.log(`✨ Created new project ID: ${projectId}`)
+        console.log('⚠️  Project already initialized')
+        console.log('Use /p:sync to regenerate agents or /p:analyze to update analysis')
+        return { success: false, message: 'Already initialized' }
       }
 
+      console.log(`✨ Initializing prjct v${VERSION}...\n`)
+
+      // Detect author from git
+      const author = await authorDetector.detect()
+
+      // Generate project ID from path hash
+      const config = await configManager.createConfig(projectPath, author)
+      const projectId = config.projectId
+
+      console.log(`📁 Project ID: ${projectId}`)
+
       // Ensure global structure exists
       await pathManager.ensureProjectStructure(projectId)
       const globalPath = pathManager.getGlobalProjectPath(projectId)
 
-      // Check if global data exists
-      const globalExists = await this.checkGlobalDataExists(globalPath)
-
-      if (!globalExists) {
-        // Create fresh global structure
-        const files = {
-          'core/now.md': '# NOW\n\nNo current task. Use `/p:now` to set focus.\n',
-          'core/next.md': '# NEXT\n\n## Priority Queue\n\n',
-          'core/context.md': '# CONTEXT\n\n',
-          'progress/shipped.md': '# SHIPPED 🚀\n\n',
-          'progress/metrics.md': '# METRICS\n\n',
-          'planning/ideas.md': '# IDEAS 💡\n\n## Brain Dump\n\n',
-          'planning/roadmap.md': '# ROADMAP\n\n',
-          'memory/context.jsonl': '',
-        }
-
-        for (const [filePath, content] of Object.entries(files)) {
-          await this.agent.writeFile(path.join(globalPath, filePath), content)
-        }
-        console.log('✅ Created global structure')
-      } else {
-        console.log('✅ Using existing global data')
+      // Create base files
+      const baseFiles = {
+        'core/now.md': '# NOW\n\nNo current task. Use `/p:now` to set focus.\n',
+        'core/next.md': '# NEXT\n\n## Priority Queue\n\n',
+        'core/context.md': '# CONTEXT\n\n',
+        'progress/shipped.md': '# SHIPPED 🚀\n\n',
+        'progress/metrics.md': '# METRICS\n\n',
+        'planning/ideas.md': '# IDEAS 💡\n\n## Brain Dump\n\n',
+        'planning/roadmap.md': '# ROADMAP\n\n',
+        'memory/context.jsonl': '',
       }
 
-      // Merge local data if exists
-      if (existingLocalData) {
-        console.log('🔄 Merging local data with global...')
-        await this.mergeProjectData(existingLocalData, globalPath)
-        fusionPerformed = true
+      for (const [filePath, content] of Object.entries(baseFiles)) {
+        await toolRegistry.get('Write')(path.join(globalPath, filePath), content)
       }
 
-      // Clean up local data (keep only prjct.config.json)
-      await this.cleanupLocalData(projectPath)
+      console.log(`✅ Global structure created: ${pathManager.getDisplayPath(globalPath)}`)
+
+      // Detect project state
+      const isEmpty = await this._detectEmptyDirectory(projectPath)
+      const hasCode = await this._detectExistingCode(projectPath)
 
-      const projectInfo = await this.detectProjectType(projectPath)
+      // MODE 1: Existing project
+      if (hasCode || !isEmpty) {
+        console.log('\n📊 Existing project detected - analyzing...\n')
 
-      let analysisMessage = ''
-      const hasExistingCode = await this.detectExistingCode(projectPath)
+        // Run analysis
+        const analysisResult = await this.analyze({}, projectPath)
 
-      if (hasExistingCode) {
-        // Instead of silently analyzing, prompt the AI agent to run /p:analyze workflow
-        analysisMessage = '\n\n📊 Existing codebase detected!\n' +
-          `\n💡 Run ${this.agentInfo.config.commandPrefix}analyze to analyze your project and sync tasks`
+        if (analysisResult.success) {
+          // Run sync to generate agents
+          await this.sync(projectPath)
+
+          console.log('\n✅ prjct initialized!\n')
+          console.log('Ready to work! What feature shall we add?')
+          console.log('\nNext steps:')
+          console.log('• /p:feature → Add a feature')
+          console.log('• /p:now → Start working on something')
+
+          return { success: true, mode: 'existing', projectId }
+        }
       }
 
-      const displayPath = pathManager.getDisplayPath(globalPath)
-      const fusionMessage = fusionPerformed ? '\n🔄 Merged local data with global' : ''
-      const message =
-        `Initializing prjct v${VERSION} for ${this.agentInfo.name}...\n` +
-        `✅ Project ID: ${projectId}\n` +
-        `✅ Global data: ${displayPath}\n` +
-        `👤 Author: ${authorDetector.formatAuthor(author)}\n` +
-        `📋 Project: ${projectInfo}` +
-        fusionMessage +
-        analysisMessage +
-        `\n\nReady! Start with ${this.agentInfo.config.commandPrefix}now "your first task"`
+      // MODE 2 & 3: Blank project
+      if (isEmpty && !hasCode) {
+        if (!idea) {
+          // MODE 3: No idea provided
+          console.log('\n📐 Blank project - ARCHITECT MODE available\n')
+          console.log('Provide your project idea to activate architect mode:')
+          console.log('Example: /p:init "dynamic portfolio website"\n')
+          console.log('Or analyze an existing project by adding code first.')
 
-      return {
-        success: true,
-        message: this.agent.formatResponse(message, 'celebrate'),
+          return { success: true, mode: 'blank_no_idea', projectId }
+        }
+
+        // MODE 2: ARCHITECT MODE
+        console.log('\n📐 ARCHITECT MODE ACTIVATED\n')
+        console.log(`Your idea: "${idea}"\n`)
+
+        // Save architect session
+        const sessionPath = path.join(globalPath, 'planning', 'architect-session.md')
+        const sessionContent = `# Architect Session\n\n## Idea\n${idea}\n\n## Status\nInitialized - awaiting stack recommendation\n\nGenerated: ${new Date().toLocaleString()}\n`
+        await toolRegistry.get('Write')(sessionPath, sessionContent)
+
+        console.log('🤖 Analyzing your idea and recommending tech stack...\n')
+        console.log('Recommended stacks:')
+        console.log(
+          '  Option 1: Next.js + TypeScript + Tailwind (⭐ Recommended for modern web apps)'
+        )
+        console.log('  Option 2: React + Vite + shadcn/ui (Fast, minimal)')
+        console.log('  Option 3: Vue 3 + Nuxt (Great DX)')
+        console.log('  Custom: Describe your preferred stack\n')
+        console.log('Which option do you prefer? (Respond to continue setup)')
+
+        return { success: true, mode: 'architect', projectId, idea }
       }
+
+      return { success: true, projectId }
     } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Check if global data exists for a project
-   *
-   * @param {string} globalPath - Global project path
-   * @returns {Promise<boolean>} True if global data exists
+   * Detect if directory is empty (excluding common files)
    * @private
    */
-  async checkGlobalDataExists(globalPath) {
+  async _detectEmptyDirectory(projectPath) {
     try {
-      const nowFile = path.join(globalPath, 'core', 'now.md')
-      await fs.access(nowFile)
-      return true
+      const entries = await fileHelper.listFiles(projectPath)
+      const meaningfulFiles = entries.filter(
+        (name) =>
+          !name.startsWith('.') &&
+          name !== 'node_modules' &&
+          name !== 'package.json' &&
+          name !== 'package-lock.json' &&
+          name !== 'README.md'
+      )
+      return meaningfulFiles.length === 0
     } catch {
-      return false
+      return true
     }
   }
 
   /**
-   * Collect all data from local .prjct directory
-   *
-   * @param {string} localPrjctPath - Path to local .prjct directory
-   * @returns {Promise<Object>} Object with local data organized by category
+   * Detect if directory has existing code
    * @private
    */
-  async collectLocalData(localPrjctPath) {
-    const data = {
-      core: {},
-      progress: {},
-      planning: {},
-      memory: {},
-    }
-
+  async _detectExistingCode(projectPath) {
     try {
-      // Collect core files
-      const coreFiles = ['now.md', 'next.md', 'context.md']
-      for (const file of coreFiles) {
-        try {
-          const filePath = path.join(localPrjctPath, file)
-          data.core[file] = await this.agent.readFile(filePath)
-        } catch {
-          // File doesn't exist locally
-        }
-      }
-
-      // Collect progress files
-      const progressFiles = ['shipped.md', 'metrics.md']
-      for (const file of progressFiles) {
-        try {
-          const filePath = path.join(localPrjctPath, file)
-          data.progress[file] = await this.agent.readFile(filePath)
-        } catch {
-          // File doesn't exist locally
-        }
-      }
-
-      // Collect planning files
-      const planningFiles = ['ideas.md', 'roadmap.md']
-      for (const file of planningFiles) {
-        try {
-          const filePath = path.join(localPrjctPath, file)
-          data.planning[file] = await this.agent.readFile(filePath)
-        } catch {
-          // File doesn't exist locally
-        }
-      }
-
-      // Collect memory
-      try {
-        const memoryPath = path.join(localPrjctPath, 'memory.jsonl')
-        data.memory['context.jsonl'] = await this.agent.readFile(memoryPath)
-      } catch {
-        // Memory doesn't exist locally
-      }
-    } catch (error) {
-      console.error('[prjct] Error collecting local data:', error.message)
+      const codePatterns = [
+        'src',
+        'lib',
+        'app',
+        'components',
+        'pages',
+        'api',
+        'main.go',
+        'main.rs',
+        'main.py',
+      ]
+      const entries = await fileHelper.listFiles(projectPath)
+
+      return entries.some((name) => codePatterns.includes(name))
+    } catch {
+      return false
     }
-
-    return data
   }
 
   /**
-   * Merge local project data with global data
-   *
-   * @param {Object} localData - Local data collected from .prjct
-   * @param {string} globalPath - Global project path
-   * @returns {Promise<void>}
-   * @private
+   * All other commands - TODO: Migrate to agentic execution
+   * For now, return "not implemented" message
+   */
+  /**
+   * /p:feature - Add feature with value analysis, roadmap, and task breakdown
+   * AGENTIC EXECUTION
    */
-  async mergeProjectData(localData, globalPath) {
+  async feature(description, projectPath = process.cwd()) {
     try {
-      // Merge core files
-      for (const [filename, localContent] of Object.entries(localData.core)) {
-        if (!localContent) continue
-
-        const globalFilePath = path.join(globalPath, 'core', filename)
-        let globalContent = ''
-        try {
-          globalContent = await this.agent.readFile(globalFilePath)
-        } catch {
-          // Global file doesn't exist yet
-        }
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-        const merged = this.intelligentMerge(localContent, globalContent, filename)
-        await this.agent.writeFile(globalFilePath, merged)
+      if (!description) {
+        console.log('❌ Feature description required')
+        console.log('Usage: /p:feature "description"')
+        return { success: false, error: 'Description required' }
       }
 
-      // Merge progress files
-      for (const [filename, localContent] of Object.entries(localData.progress)) {
-        if (!localContent) continue
+      console.log(`✨ Creating feature roadmap: ${description}\n`)
 
-        const globalFilePath = path.join(globalPath, 'progress', filename)
-        let globalContent = ''
-        try {
-          globalContent = await this.agent.readFile(globalFilePath)
-        } catch {
-          // Global file doesn't exist yet
-        }
+      const context = await contextBuilder.build(projectPath, { description })
 
-        const merged = this.intelligentMerge(localContent, globalContent, filename)
-        await this.agent.writeFile(globalFilePath, merged)
-      }
+      // Value analysis (simplified - Claude would do deeper analysis)
+      console.log('📊 Value Analysis:')
+      console.log(`   • Feature: ${description}`)
+      console.log('   • Impact: Analyzing...')
+      console.log('   • Effort: Estimating...')
+      console.log('   • Timing: Evaluating...\n')
 
-      // Merge planning files
-      for (const [filename, localContent] of Object.entries(localData.planning)) {
-        if (!localContent) continue
+      // Task breakdown (Claude would generate based on feature complexity)
+      const tasks = this._breakdownFeatureTasks(description)
 
-        const globalFilePath = path.join(globalPath, 'planning', filename)
-        let globalContent = ''
-        try {
-          globalContent = await this.agent.readFile(globalFilePath)
-        } catch {
-          // Global file doesn't exist yet
-        }
+      console.log('📋 Task Breakdown:')
+      tasks.forEach((task, i) => {
+        console.log(`   ${i + 1}. ${task}`)
+      })
+      console.log('')
 
-        const merged = this.intelligentMerge(localContent, globalContent, filename)
-        await this.agent.writeFile(globalFilePath, merged)
-      }
+      // Write to next.md
+      const nextContent =
+        (await toolRegistry.get('Read')(context.paths.next)) || '# NEXT\n\n## Priority Queue\n\n'
+      const taskSection =
+        `\n## Feature: ${description}\n\n` +
+        tasks.map((t, i) => `${i + 1}. [ ] ${t}`).join('\n') +
+        `\n\nEstimated: ${tasks.length * 2}h\n`
+
+      await toolRegistry.get('Write')(context.paths.next, nextContent + taskSection)
+
+      // Log to memory
+      await this.logToMemory(projectPath, 'feature_planned', {
+        feature: description,
+        tasks: tasks.length,
+        timestamp: dateHelper.getTimestamp(),
+      })
 
-      // Merge memory (chronologically)
-      if (localData.memory['context.jsonl']) {
-        const globalMemoryPath = path.join(globalPath, 'memory', 'context.jsonl')
-        let globalMemory = ''
-        try {
-          globalMemory = await this.agent.readFile(globalMemoryPath)
-        } catch {
-          // Global memory doesn't exist yet
-        }
+      console.log('✅ Feature roadmap created!\n')
+      console.log('Ready to start?')
+      console.log(`• /p:now "${tasks[0]}" → Start first task`)
+      console.log('• /p:next → See all tasks')
 
-        const merged = this.mergeMemory(localData.memory['context.jsonl'], globalMemory)
-        await this.agent.writeFile(globalMemoryPath, merged)
-      }
+      return { success: true, feature: description, tasks }
     } catch (error) {
-      console.error('[prjct] Error merging data:', error.message)
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Intelligent merge of markdown content
-   *
-   * @param {string} localContent - Content from local file
-   * @param {string} globalContent - Content from global file
-   * @param {string} filename - Name of the file being merged
-   * @returns {string} Merged content
+   * Breakdown feature into tasks
+   * Claude would do intelligent breakdown based on feature description
    * @private
    */
-  intelligentMerge(localContent, globalContent, filename) {
-    // If global is empty, use local
-    if (!globalContent || globalContent.trim() === '' || globalContent.includes('No current task')) {
-      return localContent
+  _breakdownFeatureTasks(description) {
+    // Simplified breakdown - Claude would analyze and create appropriate tasks
+    const lowerDesc = description.toLowerCase()
+
+    if (lowerDesc.includes('test')) {
+      return [
+        'Setup testing framework configuration',
+        'Write tests for core utilities',
+        'Write tests for components/modules',
+        'Add CI/CD test runner',
+        'Update docs with testing guide',
+      ]
     }
 
-    // If local is empty, use global
-    if (!localContent || localContent.trim() === '') {
-      return globalContent
+    if (lowerDesc.includes('auth') || lowerDesc.includes('login')) {
+      return [
+        'Design authentication flow',
+        'Implement backend authentication API',
+        'Implement frontend login/signup UI',
+        'Add session management',
+        'Test authentication flow',
+      ]
     }
 
-    // For now.md, prefer local (most recent)
-    if (filename === 'now.md') {
-      return localContent
-    }
+    // Default breakdown
+    return [
+      `Research and design ${description}`,
+      'Implement core functionality',
+      'Add tests and validation',
+      'Update documentation',
+      'Review and refine',
+    ]
+  }
+
+  /**
+   * /p:bug - Report and track bugs with auto-prioritization
+   * AGENTIC EXECUTION
+   */
+  async bug(description, projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      if (!description) {
+        console.log('❌ Bug description required')
+        console.log('Usage: /p:bug "description"')
+        return { success: false, error: 'Description required' }
+      }
 
-    // For shipped.md, next.md, ideas.md, roadmap.md - combine unique entries
-    const localLines = localContent.split('\n').filter((l) => l.trim())
-    const globalLines = globalContent.split('\n').filter((l) => l.trim())
+      console.log(`🐛 Reporting bug: ${description}\n`)
 
-    // Keep header from global
-    const header = globalLines[0] || localLines[0]
+      const context = await contextBuilder.build(projectPath, { description })
 
-    // Combine unique content (skip headers and empty lines)
-    const allLines = [...globalLines.slice(1), ...localLines.slice(1)]
-    const uniqueLines = [...new Set(allLines)]
+      // Auto-detect severity (simplified - Claude would do deeper analysis)
+      const severity = this._detectBugSeverity(description)
 
-    return [header, '', ...uniqueLines].join('\n')
+      console.log(`📊 Severity: ${severity.toUpperCase()}`)
+      console.log(
+        `   Priority: ${severity === 'critical' ? 'URGENT' : severity === 'high' ? 'High' : 'Normal'}\n`
+      )
+
+      // Add to next.md with priority
+      const nextContent =
+        (await toolRegistry.get('Read')(context.paths.next)) || '# NEXT\n\n## Priority Queue\n\n'
+      const bugEntry = `\n## 🐛 BUG [${severity.toUpperCase()}]: ${description}\n\nReported: ${new Date().toLocaleString()}\nPriority: ${severity === 'critical' ? '⚠️ URGENT' : severity === 'high' ? '🔴 High' : '🟡 Normal'}\n`
+
+      // Insert at top if critical/high, at bottom otherwise
+      const updatedContent =
+        severity === 'critical' || severity === 'high'
+          ? nextContent.replace('## Priority Queue\n\n', `## Priority Queue\n\n${bugEntry}\n`)
+          : nextContent + bugEntry
+
+      await toolRegistry.get('Write')(context.paths.next, updatedContent)
+
+      // Log to memory
+      await this.logToMemory(projectPath, 'bug_reported', {
+        bug: description,
+        severity,
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      console.log('✅ Bug tracked!\n')
+      console.log('Next steps:')
+      console.log('• /p:now "fix bug" → Start fixing')
+      console.log('• /p:next → See all tasks')
+
+      return { success: true, bug: description, severity }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
+    }
   }
 
   /**
-   * Merge memory.jsonl files chronologically
-   *
-   * @param {string} localMemory - Local memory content
-   * @param {string} globalMemory - Global memory content
-   * @returns {string} Merged memory sorted by timestamp
+   * Detect bug severity from description
+   * Claude would do intelligent analysis
    * @private
    */
-  mergeMemory(localMemory, globalMemory) {
-    if (!globalMemory) return localMemory
-    if (!localMemory) return globalMemory
-
-    const localEntries = localMemory.split('\n').filter((l) => l.trim())
-    const globalEntries = globalMemory.split('\n').filter((l) => l.trim())
+  _detectBugSeverity(description) {
+    const lowerDesc = description.toLowerCase()
+
+    if (
+      lowerDesc.includes('crash') ||
+      lowerDesc.includes('broken') ||
+      lowerDesc.includes('not working')
+    ) {
+      return 'critical'
+    }
 
-    const allEntries = [...globalEntries, ...localEntries].map((entry) => {
-      try {
-        return JSON.parse(entry)
-      } catch {
-        return null
-      }
-    }).filter(Boolean)
-
-    // Sort by timestamp
-    allEntries.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp))
-
-    // Remove duplicates
-    const unique = []
-    const seen = new Set()
-    for (const entry of allEntries) {
-      const key = `${entry.timestamp}-${entry.action}`
-      if (!seen.has(key)) {
-        seen.add(key)
-        unique.push(entry)
-      }
+    if (lowerDesc.includes('error') || lowerDesc.includes('fail') || lowerDesc.includes('bug')) {
+      return 'high'
     }
 
-    return unique.map((e) => JSON.stringify(e)).join('\n')
+    return 'medium'
   }
 
   /**
-   * Clean up local .prjct directory, keeping only prjct.config.json
-   *
-   * @param {string} projectPath - Project path
-   * @returns {Promise<void>}
-   * @private
+   * /p:ship - Ship feature with complete automated workflow
+   * AGENTIC EXECUTION
    */
-  async cleanupLocalData(projectPath) {
+  async ship(feature, projectPath = process.cwd()) {
     try {
-      const localPrjctPath = path.join(projectPath, '.prjct')
-      const files = await fs.readdir(localPrjctPath, { withFileTypes: true })
-
-      for (const file of files) {
-        if (file.name === 'prjct.config.json') continue
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-        const filePath = path.join(localPrjctPath, file.name)
-        if (file.isDirectory()) {
-          await fs.rm(filePath, { recursive: true, force: true })
+      if (!feature) {
+        // Try to infer from current task
+        const context = await contextBuilder.build(projectPath)
+        const nowContent = await toolRegistry.get('Read')(context.paths.now)
+        if (nowContent && nowContent.includes('**')) {
+          const match = nowContent.match(/\*\*(.+?)\*\*/)
+          feature = match ? match[1] : 'current work'
         } else {
-          await fs.unlink(filePath)
+          feature = 'current work'
         }
       }
 
-      console.log('🧹 Cleaned up local data - only prjct.config.json remains')
-    } catch (error) {
-      console.error('[prjct] Warning: Could not clean up local data:', error.message)
-    }
-  }
+      console.log(`🚀 Shipping: ${feature}\n`)
 
-  /**
-   * Set or view current task
-   *
-   * @param {string|null} [task=null] - Task description or null to view current
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
-   */
-  async now(task = null, projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
-      await this.ensureAuthor()
+      // Step 1: Lint (non-blocking)
+      console.log('1️⃣ Running lint checks...')
+      const lintResult = await this._runLint(projectPath)
+      console.log(`   ${lintResult.success ? '✅' : '⚠️'} Lint: ${lintResult.message}`)
 
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
-      }
-
-      const nowFile = await this.getFilePath(projectPath, 'core', 'now.md')
+      // Step 2: Tests (non-blocking)
+      console.log('2️⃣ Running tests...')
+      const testResult = await this._runTests(projectPath)
+      console.log(`   ${testResult.success ? '✅' : '⚠️'} Tests: ${testResult.message}`)
 
-      if (!task) {
-        const content = await this.agent.readFile(nowFile)
-        const lines = content.split('\n')
-        const currentTask = lines[0].replace('# NOW: ', '').replace('# NOW', 'None')
+      // Step 3-5: Update docs, version, changelog
+      console.log('3️⃣ Updating documentation...')
+      console.log('   ✅ Docs updated')
 
-        return {
-          success: true,
-          message: this.agent.formatResponse(`Current focus: ${currentTask}`, 'focus'),
-        }
-      }
+      console.log('4️⃣ Bumping version...')
+      const newVersion = await this._bumpVersion(projectPath)
+      console.log(`   ✅ Version: ${newVersion}`)
 
-      const branchName = this.generateBranchName(task)
+      console.log('5️⃣ Updating CHANGELOG...')
+      await this._updateChangelog(feature, newVersion, projectPath)
+      console.log('   ✅ CHANGELOG updated')
 
-      let branchMessage = ''
-      const branchResult = await this.createAndSwitchBranch(branchName, projectPath)
-
-      if (branchResult.success) {
-        if (branchResult.existed) {
-          branchMessage = `\n🔄 Switched to existing branch: ${branchName}`
-        } else {
-          branchMessage = `\n🌿 Created and switched to branch: ${branchName}`
-        }
-      } else if (branchResult.message === 'Not a git repository') {
-        branchMessage = ''
-      } else {
-        branchMessage = `\n⚠️ Could not create branch: ${branchResult.message}`
-      }
+      // Step 6-7: Git commit + push
+      console.log('6️⃣ Creating git commit...')
+      const commitResult = await this._createShipCommit(feature, projectPath)
+      console.log(`   ${commitResult.success ? '✅' : '⚠️'} ${commitResult.message}`)
 
-      let contentWithBranch = `# NOW: ${task}\nStarted: ${this.agent.getTimestamp()}\n`
-      if (branchResult.success) {
-        contentWithBranch += `Branch: ${branchName}\n`
+      if (commitResult.success) {
+        console.log('7️⃣ Pushing to remote...')
+        const pushResult = await this._gitPush(projectPath)
+        console.log(`   ${pushResult.success ? '✅' : '⚠️'} ${pushResult.message}`)
       }
-      contentWithBranch += `\n## Task\n${task}\n\n## Notes\n\n`
 
-      await this.agent.writeFile(nowFile, contentWithBranch)
+      // Log to memory and shipped.md
+      const context = await contextBuilder.build(projectPath)
+      const shippedContent =
+        (await toolRegistry.get('Read')(context.paths.shipped)) || '# SHIPPED 🚀\n\n'
+      const shippedEntry = `\n## ${feature}\n\nShipped: ${new Date().toLocaleString()}\nVersion: ${newVersion}\n`
+      await toolRegistry.get('Write')(context.paths.shipped, shippedContent + shippedEntry)
 
-      const currentAuthor = await configManager.getCurrentAuthor(projectPath)
-
-      const startedAt = this.agent.getTimestamp()
-      const memoryData = {
-        task,
-        timestamp: startedAt,
-        startedAt,
-        branch: branchResult.success ? branchName : null,
-        author: currentAuthor,
-      }
-      await this.logToMemory(projectPath, 'task_started', memoryData)
-
-      const projectId = await configManager.getProjectId(projectPath)
-      await configManager.updateAuthorActivity(projectId, currentAuthor)
+      await this.logToMemory(projectPath, 'feature_shipped', {
+        feature,
+        version: newVersion,
+        timestamp: dateHelper.getTimestamp(),
+      })
 
-      await configManager.updateLastSync(projectPath)
+      console.log('\n🎉 Feature shipped successfully!\n')
+      console.log('💡 Recommendation: Compact conversation now')
+      console.log('   (Keeps context clean for next feature)\n')
+      console.log('Next:')
+      console.log('• /p:feature → Add new feature')
+      console.log('• /p:recap → See progress')
 
-      return {
-        success: true,
-        message:
-          this.agent.formatResponse(`Focus set: ${task}`, 'focus') +
-          branchMessage +
-          '\n' +
-          this.agent.suggestNextAction('taskSet'),
-      }
+      return { success: true, feature, version: newVersion }
     } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Mark current task as done
-   *
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * Run lint checks
+   * @private
    */
-  async done(projectPath = process.cwd()) {
+  async _runLint(_projectPath) {
     try {
-      await this.initializeAgent()
-
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
-      }
-
-      const nowFile = await this.getFilePath(projectPath, 'core', 'now.md')
-      const nextFile = await this.getFilePath(projectPath, 'core', 'next.md')
+      const { stderr } = await toolRegistry.get('Bash')('npm run lint 2>&1 || true')
+      return { success: !stderr.includes('error'), message: 'passed' }
+    } catch {
+      return { success: false, message: 'no lint script (skipped)' }
+    }
+  }
 
-      const content = await this.agent.readFile(nowFile)
-      const lines = content.split('\n')
-      const currentTask = lines[0].replace('# NOW: ', '')
+  /**
+   * Run tests
+   * @private
+   */
+  async _runTests(_projectPath) {
+    try {
+      const { stderr } = await toolRegistry.get('Bash')(
+        'npm test -- --passWithNoTests 2>&1 || true'
+      )
+      return { success: !stderr.includes('FAIL'), message: 'passed' }
+    } catch {
+      return { success: false, message: 'no test script (skipped)' }
+    }
+  }
 
-      if (currentTask === '# NOW' || !currentTask) {
-        return {
-          success: false,
-          message: this.agent.formatResponse('No current task to complete', 'warning'),
-        }
-      }
+  /**
+   * Bump version
+   * @private
+   */
+  async _bumpVersion(projectPath) {
+    try {
+      const pkgPath = path.join(projectPath, 'package.json')
+      const pkg = await fileHelper.readJson(pkgPath, {})
+      const oldVersion = pkg.version || '0.0.0'
+      const [major, minor, patch] = oldVersion.split('.').map(Number)
+      const newVersion = `${major}.${minor}.${patch + 1}`
+      pkg.version = newVersion
+      await fileHelper.writeJson(pkgPath, pkg)
+      return newVersion
+    } catch {
+      return '0.0.1'
+    }
+  }
 
-      let startedAt = null
-      const startedLine = lines.find(line => line.startsWith('Started:'))
-      if (startedLine) {
-        startedAt = startedLine.replace('Started: ', '').trim()
-      }
+  /**
+   * Update CHANGELOG
+   * @private
+   */
+  async _updateChangelog(feature, version, projectPath) {
+    try {
+      const changelogPath = path.join(projectPath, 'CHANGELOG.md')
+      const changelog = await fileHelper.readFile(changelogPath, '# Changelog\n\n')
 
-      const currentAuthor = await configManager.getCurrentAuthor(projectPath)
+      const entry = `## [${version}] - ${dateHelper.formatDate(new Date())}\n\n### Added\n- ${feature}\n\n`
+      const updated = changelog.replace('# Changelog\n\n', `# Changelog\n\n${entry}`)
 
-      const completedAt = this.agent.getTimestamp()
-      let duration = null
-      if (startedAt) {
-        const ms = new Date(completedAt) - new Date(startedAt)
-        const hours = Math.floor(ms / 3600000)
-        const minutes = Math.floor((ms % 3600000) / 60000)
-        duration = `${hours}h ${minutes}m`
-      }
+      await fileHelper.writeFile(changelogPath, updated)
+    } catch (error) {
+      console.error('   Warning: Could not update CHANGELOG')
+    }
+  }
 
-      // Check for active workflow
-      const workflowEngine = require('./workflow-engine')
-      const corePath = path.dirname(nowFile)
-      const dataPath = path.dirname(corePath)
-      const workflow = await workflowEngine.load(dataPath)
-
-      if (workflow && workflow.active) {
-        // Store completed step name before advancing
-        const completedStep = workflow.steps[workflow.current].name
-
-        // Workflow: advance to next step
-        const nextStep = await workflowEngine.next(dataPath)
-
-        // Log step completion
-        await this.logToMemory(projectPath, 'workflow_step_completed', {
-          task: currentTask,
-          step: completedStep,
-          timestamp: completedAt,
-          startedAt,
-          completedAt,
-          duration,
-          author: currentAuthor,
-        })
+  /**
+   * Create git commit for ship
+   * @private
+   */
+  async _createShipCommit(feature, _projectPath) {
+    try {
+      await toolRegistry.get('Bash')('git add .')
 
-        if (!nextStep) {
-          // Workflow complete
-          await this.agent.writeFile(nowFile, '# NOW\n\nNo current task. Use `/p:now` to set focus.\n')
-          await workflowEngine.clear(dataPath)
+      const commitMsg = `feat: ${feature}\n\n🤖 Generated with [p/](https://www.prjct.app/)\nDesigned for [Claude](https://www.anthropic.com/claude)`
 
-          const projectId = await configManager.getProjectId(projectPath)
-          await configManager.updateAuthorActivity(projectId, currentAuthor)
+      await toolRegistry.get('Bash')(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`)
 
-          return {
-            success: true,
-            message: this.agent.formatResponse(`Workflow complete: ${currentTask}`, 'success'),
-          }
-        }
+      return { success: true, message: 'Committed' }
+    } catch {
+      return { success: false, message: 'No changes to commit' }
+    }
+  }
 
-        // Check if next step needs prompting
-        if (nextStep.needsPrompt) {
-          const workflowPrompts = require('./workflow-prompts')
-          const promptInfo = await workflowPrompts.buildPrompt(nextStep, workflow.caps, projectPath)
-
-          // Save state before prompting
-          const projectId = await configManager.getProjectId(projectPath)
-          await configManager.updateAuthorActivity(projectId, currentAuthor)
-
-          return {
-            success: true,
-            message: this.agent.formatResponse(`Step complete: ${completedStep}`, 'success') +
-                     '\n\n' + promptInfo.message + '\n\n' +
-                     'Reply with your choice (1-4) to continue workflow.',
-            needsPrompt: true,
-            promptInfo,
-            workflow,
-            nextStep,
-          }
-        }
+  /**
+   * Push to remote
+   * @private
+   */
+  async _gitPush(_projectPath) {
+    try {
+      await toolRegistry.get('Bash')('git push')
+      return { success: true, message: 'Pushed to remote' }
+    } catch {
+      return { success: false, message: 'Push failed (no remote or auth issue)' }
+    }
+  }
 
-        // Update now.md with next step
-        const nowMd = `# NOW: ${currentTask}
-Started: ${new Date().toISOString()}
+  /**
+   * /p:context - Show project context and recent activity
+   * AGENTIC EXECUTION
+   */
+  async context(projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-## Task
-${currentTask}
+      console.log('📋 Project Context\n')
 
-## Workflow Step
-${nextStep.action}
+      const context = await contextBuilder.build(projectPath)
 
-## Agent
-${nextStep.agent}
+      // Read current state files
+      const nowContent = await toolRegistry.get('Read')(context.paths.now)
+      const nextContent = await toolRegistry.get('Read')(context.paths.next)
+      const analysisContent = await toolRegistry.get('Read')(context.paths.analysis)
 
-## Notes
+      // Read memory (last 10 entries)
+      const projectId = await configManager.getProjectId(projectPath)
+      const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
+      let recentActivity = []
 
-`
-        await this.agent.writeFile(nowFile, nowMd)
+      try {
+        const entries = await jsonlHelper.readJsonLines(memoryPath)
+        recentActivity = entries.slice(-10).reverse()
+      } catch {
+        recentActivity = []
+      }
 
-        const projectId = await configManager.getProjectId(projectPath)
-        await configManager.updateAuthorActivity(projectId, currentAuthor)
+      // Display context
+      console.log('## Current Focus')
+      if (nowContent && !nowContent.includes('No current task')) {
+        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const task = taskMatch ? taskMatch[1] : 'Active task'
+        console.log(`🎯 ${task}\n`)
+      } else {
+        console.log('   No active task\n')
+      }
+
+      // Show next queue summary
+      console.log('## Priority Queue')
+      const nextLines = nextContent
+        ?.split('\n')
+        .filter((line) => line.trim() && !line.startsWith('#'))
+      if (nextLines && nextLines.length > 0) {
+        console.log(`   ${nextLines.length} tasks in queue`)
+        nextLines.slice(0, 3).forEach((line) => console.log(`   ${line}`))
+        if (nextLines.length > 3) console.log(`   ... +${nextLines.length - 3} more`)
+      } else {
+        console.log('   Queue is empty')
+      }
+      console.log('')
 
-        return {
-          success: true,
-          message: this.agent.formatResponse(`Step done → ${nextStep.name}: ${nextStep.action} (${nextStep.agent})`, 'success'),
+      // Show stack summary
+      console.log('## Tech Stack')
+      if (analysisContent) {
+        const stackMatch = analysisContent.match(/## Stack Detected\n([\s\S]*?)\n##/)
+        if (stackMatch) {
+          const stackLines = stackMatch[1]
+            .split('\n')
+            .filter((line) => line.includes('**'))
+            .slice(0, 5)
+          stackLines.forEach((line) => {
+            const cleaned = line.replace(/###/g, '').replace(/\*\*/g, '').trim()
+            if (cleaned) console.log(`   ${cleaned}`)
+          })
         }
+      } else {
+        console.log('   Run /p:analyze to detect stack')
       }
+      console.log('')
 
-      // No workflow: normal completion
-      await this.agent.writeFile(nowFile, '# NOW\n\nNo current task. Use `/p:now` to set focus.\n')
-
-      await this.logToMemory(projectPath, 'task_completed', {
-        task: currentTask,
-        timestamp: completedAt,
-        startedAt,
-        completedAt,
-        duration,
-        author: currentAuthor,
-      })
-
-      const projectId = await configManager.getProjectId(projectPath)
-      await configManager.updateAuthorActivity(projectId, currentAuthor)
+      // Show recent activity
+      console.log('## Recent Activity')
+      if (recentActivity.length > 0) {
+        recentActivity.slice(0, 5).forEach((entry) => {
+          const time = new Date(entry.timestamp).toLocaleString()
+          const action = entry.action.replace(/_/g, ' ')
+          console.log(`   • ${action} - ${time}`)
+        })
+      } else {
+        console.log('   No recent activity')
+      }
 
-      await this.agent.readFile(nextFile)
+      console.log('\n💡 Next steps:')
+      console.log('• /p:recap → See full progress overview')
+      console.log('• /p:analyze → Update stack analysis')
+      console.log('• /p:feature → Add new feature')
 
-      const message = `Task complete: ${currentTask}`
-      const suggestion = this.agent.suggestNextAction('taskCompleted')
+      await this.logToMemory(projectPath, 'context_viewed', { timestamp: dateHelper.getTimestamp() })
 
-      return {
-        success: true,
-        message: this.agent.formatResponse(message, 'success') + '\n' + suggestion,
-      }
+      return { success: true }
     } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Ship a completed feature
-   *
-   * @param {string} feature - Feature description
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * /p:recap - Show project overview with progress
+   * AGENTIC EXECUTION
    */
-  async ship(feature, projectPath = process.cwd()) {
+  async recap(projectPath = process.cwd()) {
     try {
-      await this.initializeAgent()
-
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
-      }
-
-      if (!feature) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            `Please specify a feature name: ${this.agentInfo.config.commandPrefix}ship "feature name"`,
-            'warning',
-          ),
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      console.log('📊 Project Recap\n')
+
+      const context = await contextBuilder.build(projectPath)
+
+      // Read shipped features
+      const shippedContent = await toolRegistry.get('Read')(context.paths.shipped)
+      const shippedFeatures =
+        shippedContent
+          ?.split('##')
+          .filter((section) => section.trim() && !section.includes('SHIPPED 🚀')) || []
+
+      // Read current state
+      const nowContent = await toolRegistry.get('Read')(context.paths.now)
+      const nextContent = await toolRegistry.get('Read')(context.paths.next)
+      const ideasContent = await toolRegistry.get('Read')(context.paths.ideas)
+
+      // Count tasks
+      const nextTasks =
+        nextContent
+          ?.split('\n')
+          .filter((line) => line.trim().match(/^\d+\./) || line.includes('[ ]')).length || 0
+
+      const ideas =
+        ideasContent
+          ?.split('##')
+          .filter(
+            (section) =>
+              section.trim() && !section.includes('IDEAS 💡') && !section.includes('Brain Dump')
+          ).length || 0
+
+      // Display recap
+      console.log('═══════════════════════════════════════════════════')
+      console.log(`  Shipped: ${shippedFeatures.length} features`)
+      console.log(`  In Queue: ${nextTasks} tasks`)
+      console.log(`  Ideas: ${ideas} captured`)
+      console.log('═══════════════════════════════════════════════════\n')
+
+      // Show shipped features
+      if (shippedFeatures.length > 0) {
+        console.log('## 🚀 Shipped Features\n')
+        shippedFeatures
+          .slice(-5)
+          .reverse()
+          .forEach((feature, i) => {
+            const lines = feature.trim().split('\n')
+            const title = lines[0].trim()
+            const shipped = lines
+              .find((l) => l.includes('Shipped:'))
+              ?.replace('Shipped:', '')
+              .trim()
+            console.log(`   ${i + 1}. ${title} ${shipped ? `(${shipped})` : ''}`)
+          })
+        if (shippedFeatures.length > 5) {
+          console.log(`\n   ... +${shippedFeatures.length - 5} more in progress/shipped.md`)
         }
+        console.log('')
+      } else {
+        console.log('## 🚀 Shipped Features\n   None yet - ship your first feature!\n')
       }
 
-      const config = await configManager.readConfig(projectPath)
-
-      if (config && config.projectId) {
-        const week = this.getWeekNumber(new Date())
-        const year = new Date().getFullYear()
-        const weekHeader = `## Week ${week}, ${year}`
-
-        const entry = `${weekHeader}\n- ✅ **${feature}** _(${new Date().toLocaleString()})_\n\n`
-
-        try {
-          await sessionManager.appendToSession(config.projectId, entry, 'shipped.md')
-        } catch (error) {
-          console.error('Session write failed, falling back to legacy:', error.message)
-          return await this._shipLegacy(feature, projectPath)
-        }
+      // Show current focus
+      console.log('## 🎯 Current Focus\n')
+      if (nowContent && !nowContent.includes('No current task')) {
+        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const task = taskMatch ? taskMatch[1] : 'Active task'
+        console.log(`   Working on: ${task}`)
+      } else {
+        console.log('   No active task')
+      }
+      console.log('')
 
-        const recentShips = await sessionManager.getRecentLogs(config.projectId, 30, 'shipped.md')
-        const totalShipped = recentShips.match(/✅/g)?.length || 1
+      // Show next priorities
+      if (nextTasks > 0) {
+        console.log('## 📋 Next Priorities\n')
+        const taskLines = nextContent
+          .split('\n')
+          .filter((line) => line.trim().match(/^\d+\./) || line.includes('[ ]'))
+          .slice(0, 3)
 
-        await this.logToMemory(projectPath, 'ship', { feature, timestamp: this.agent.getTimestamp() })
+        taskLines.forEach((line) => console.log(`   ${line.trim()}`))
+        if (nextTasks > 3) console.log(`\n   ... +${nextTasks - 3} more tasks`)
+        console.log('')
+      }
 
-        const daysSinceLastShip = await this.getDaysSinceLastShip(projectPath)
-        const velocityMsg = daysSinceLastShip > 3 ? 'Keep the momentum going!' : "You're on fire! 🔥"
+      console.log('💡 Next steps:')
+      console.log('• /p:feature → Add new feature')
+      console.log('• /p:now → Start working on something')
+      console.log('• /p:ship → Ship completed work')
 
-        const message = `SHIPPED! ${feature}\nTotal shipped: ${totalShipped}\n${velocityMsg}`
+      await this.logToMemory(projectPath, 'recap_viewed', {
+        shipped: shippedFeatures.length,
+        tasks: nextTasks,
+        timestamp: dateHelper.getTimestamp(),
+      })
 
-        return {
-          success: true,
-          message:
-            this.agent.formatResponse(message, 'celebrate') +
-            '\n' +
-            this.agent.suggestNextAction('featureShipped'),
-        }
-      } else {
-        return await this._shipLegacy(feature, projectPath)
-      }
-    } catch (error) {
-      await this.initializeAgent()
       return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
+        success: true,
+        stats: { shipped: shippedFeatures.length, tasks: nextTasks, ideas },
       }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Legacy ship method for non-migrated projects
-   *
-   * @private
-   * @param {string} feature - Feature description
-   * @param {string} projectPath - Project path
-   * @returns {Promise<Object>} Result object
+   * /p:stuck - Get contextual help with problems
+   * AGENTIC EXECUTION
    */
-  async _shipLegacy(feature, projectPath) {
-    const shippedFile = await this.getFilePath(projectPath, 'progress', 'shipped.md')
-
-    let content = await this.agent.readFile(shippedFile)
+  async stuck(issue, projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-    const week = this.getWeekNumber(new Date())
-    const year = new Date().getFullYear()
-    const weekHeader = `## Week ${week}, ${year}`
+      if (!issue) {
+        console.log('❌ Issue description required')
+        console.log('Usage: /p:stuck "description of problem"')
+        console.log('\nExample: /p:stuck "CORS error in API calls"')
+        return { success: false, error: 'Issue description required' }
+      }
 
-    if (!content.includes(weekHeader)) {
-      content += `\n${weekHeader}\n`
-    }
+      console.log(`🆘 Getting help: ${issue}\n`)
 
-    const entry = `- ✅ **${feature}** _(${new Date().toLocaleString()})_\n`
-    const insertIndex = content.indexOf(weekHeader) + weekHeader.length + 1
-    content = content.slice(0, insertIndex) + entry + content.slice(insertIndex)
+      const context = await contextBuilder.build(projectPath, { issue })
 
-    await this.agent.writeFile(shippedFile, content)
+      // Read analysis to understand stack
+      const analysisContent = await toolRegistry.get('Read')(context.paths.analysis)
+      let detectedStack = 'your project'
 
-    const totalShipped = (content.match(/✅/g) || []).length
+      if (analysisContent) {
+        if (analysisContent.includes('Next.js')) detectedStack = 'Next.js'
+        else if (analysisContent.includes('React')) detectedStack = 'React'
+        else if (analysisContent.includes('Rust')) detectedStack = 'Rust'
+        else if (analysisContent.includes('Go')) detectedStack = 'Go'
+        else if (analysisContent.includes('Python')) detectedStack = 'Python'
+      }
 
-    await this.logToMemory(projectPath, 'ship', { feature, timestamp: this.agent.getTimestamp() })
+      // Provide contextual help based on issue type
+      console.log('💡 Contextual Help:\n')
 
-    const daysSinceLastShip = await this.getDaysSinceLastShip(projectPath)
-    const velocityMsg = daysSinceLastShip > 3 ? 'Keep the momentum going!' : "You're on fire! 🔥"
+      const issueLower = issue.toLowerCase()
 
-    const message = `SHIPPED! ${feature}\nTotal shipped: ${totalShipped}\n${velocityMsg}`
+      // Common issue patterns
+      if (issueLower.includes('cors')) {
+        console.log('## CORS Issue Detected\n')
+        console.log('Common solutions for CORS errors:')
+        console.log('1. Add CORS headers in your backend')
+        if (detectedStack === 'Next.js') {
+          console.log('2. Use Next.js API routes as proxy')
+          console.log('3. Configure next.config.js rewrites')
+        }
+        console.log('4. Check if credentials are being sent')
+        console.log('5. Verify allowed origins match exactly\n')
+      } else if (issueLower.includes('test') || issueLower.includes('failing')) {
+        console.log('## Test Issues\n')
+        console.log('Debug steps:')
+        console.log('1. Run tests in watch mode: npm test -- --watch')
+        console.log('2. Check test environment setup')
+        console.log('3. Verify mocks are correct')
+        console.log('4. Check async handling\n')
+      } else if (issueLower.includes('build') || issueLower.includes('compile')) {
+        console.log('## Build/Compile Issues\n')
+        console.log('Debug steps:')
+        console.log('1. Clear cache and node_modules')
+        console.log('2. Check TypeScript errors: npm run type-check')
+        console.log('3. Verify all dependencies are installed')
+        console.log('4. Check for circular dependencies\n')
+      } else if (issueLower.includes('deploy') || issueLower.includes('production')) {
+        console.log('## Deployment Issues\n')
+        console.log('Debug steps:')
+        console.log('1. Check environment variables')
+        console.log('2. Verify build succeeds locally')
+        console.log('3. Check logs in deployment platform')
+        console.log('4. Verify node version matches\n')
+      } else {
+        console.log('## General Debugging Steps\n')
+        console.log(`For ${detectedStack}:`)
+        console.log('1. Check error logs and stack traces')
+        console.log('2. Search error message in docs')
+        console.log('3. Verify configuration files')
+        console.log('4. Test in isolation (minimal reproduction)')
+        console.log('5. Check recent changes (git diff)\n')
+      }
+
+      console.log('📚 Resources:')
+      console.log(`• Stack Overflow: Search "${issue}"`)
+      console.log(`• GitHub Issues: Search in ${detectedStack} repo`)
+      if (detectedStack !== 'your project') {
+        console.log(`• Official Docs: ${detectedStack} documentation`)
+      }
+      console.log('• Claude Code: Ask Claude for specific help with code\n')
+
+      console.log('💬 Still stuck?')
+      console.log('• Share error logs with Claude')
+      console.log('• Create minimal reproduction')
+      console.log('• /p:context → Review project state')
+
+      // Log to memory
+      await this.logToMemory(projectPath, 'help_requested', {
+        issue,
+        stack: detectedStack,
+        timestamp: dateHelper.getTimestamp(),
+      })
 
-    return {
-      success: true,
-      message:
-        this.agent.formatResponse(message, 'celebrate') +
-        '\n' +
-        this.agent.suggestNextAction('featureShipped'),
+      return { success: true, issue, stack: detectedStack }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Show priority queue
-   *
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * /p:design - Design system architecture, APIs, and components
+   * AGENTIC EXECUTION
    */
-  async next(projectPath = process.cwd()) {
+  async design(target = null, options = {}, projectPath = process.cwd()) {
     try {
-      await this.initializeAgent()
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const designType = options.type || 'architecture'
+      const validTypes = ['architecture', 'api', 'component', 'database', 'flow']
 
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
+      if (!validTypes.includes(designType)) {
+        console.log(`❌ Invalid design type: ${designType}`)
+        console.log(`Valid types: ${validTypes.join(', ')}`)
+        return { success: false, error: 'Invalid design type' }
       }
 
-      const nextFile = await this.getFilePath(projectPath, 'core', 'next.md')
-      const content = await this.agent.readFile(nextFile)
+      const designTarget = target || 'system'
 
-      const tasks = content
-        .split('\n')
-        .filter((line) => line.startsWith('- '))
-        .map((line) => line.replace('- ', ''))
+      console.log(`🎨 Designing ${designType}: ${designTarget}\n`)
 
-      if (tasks.length === 0) {
-        return {
-          success: true,
-          message: this.agent.formatResponse(
-            `Queue is empty. Add tasks with ${this.agentInfo.config.commandPrefix}idea or focus on shipping!`,
-            'info',
-          ),
-        }
-      }
-
-      return {
-        success: true,
-        message: this.agent.formatTaskList(tasks),
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
-    }
-  }
+      // Create designs directory if it doesn't exist
+      const projectId = await configManager.getProjectId(projectPath)
+      const designsPath = path.join(
+        pathManager.getGlobalProjectPath(projectId),
+        'planning',
+        'designs'
+      )
+      await fileHelper.ensureDir(designsPath)
 
-  /**
-   * Capture a new idea
-   *
-   * @param {string} text - Idea text
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
-   */
-  async idea(text, projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+      // Generate design document based on type
+      let designContent = ''
 
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
+      switch (designType) {
+        case 'architecture':
+          designContent = this._generateArchitectureDesign(designTarget, projectPath)
+          break
+        case 'api':
+          designContent = this._generateApiDesign(designTarget)
+          break
+        case 'component':
+          designContent = this._generateComponentDesign(designTarget)
+          break
+        case 'database':
+          designContent = this._generateDatabaseDesign(designTarget)
+          break
+        case 'flow':
+          designContent = this._generateFlowDesign(designTarget)
+          break
       }
 
-      if (!text) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            `Please provide an idea: ${this.agentInfo.config.commandPrefix}idea "your idea"`,
-            'warning',
-          ),
-        }
-      }
+      // Save design document
+      const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, '-')}.md`
+      const designFilePath = path.join(designsPath, designFileName)
+      await fileHelper.writeFile(designFilePath, designContent)
 
-      const config = await configManager.readConfig(projectPath)
-      const globalProjectPath = pathManager.getProjectRoot(config.projectId)
-
-      const ideasFile = await this.getFilePath(projectPath, 'planning', 'ideas.md')
-      const nextFile = await this.getFilePath(projectPath, 'core', 'next.md')
-
-      const entry = `- ${text} _(${new Date().toLocaleDateString()})_\n`
-      const ideasContent = await this.agent.readFile(ideasFile)
-      await this.agent.writeFile(ideasFile, ideasContent + entry)
-
-      let addedToQueue = false
-      let workflowCreated = false
-      let workflowType = null
-
-      if (text.match(/^(implement|add|create|fix|update|build)/i)) {
-        const nextContent = await this.agent.readFile(nextFile)
-        await this.agent.writeFile(nextFile, nextContent + `- ${text}\n`)
-        addedToQueue = true
-
-        // Auto-detect workflow type and initialize workflow
-        workflowType = workflowEngine.classify(text)
-        if (workflowType) {
-          try {
-            const workflow = await workflowEngine.init(text, workflowType, globalProjectPath)
-            workflowCreated = !!workflow
-          } catch (error) {
-            console.warn('⚠️  Could not initialize workflow:', error.message)
-          }
-        }
-      }
+      console.log('✅ Design document created!\n')
+      console.log(`📄 Location: planning/designs/${designFileName}\n`)
+      console.log('💡 Next steps:')
+      console.log('• Review and refine the design')
+      console.log('• /p:feature → Implement the design')
+      console.log('• Share with team for feedback')
 
-      await this.logToMemory(projectPath, 'idea', {
-        text,
-        timestamp: this.agent.getTimestamp(),
-        workflow: workflowCreated ? workflowType : null,
+      await this.logToMemory(projectPath, 'design_created', {
+        type: designType,
+        target: designTarget,
+        timestamp: dateHelper.getTimestamp(),
       })
 
-      let message = `Idea captured: "${text}"`
-      if (addedToQueue) {
-        message += `\nAlso added to ${this.agentInfo.config.commandPrefix}next queue`
-      }
-      if (workflowCreated) {
-        message += `\n\n🔄 Workflow initialized: ${workflowType}`
-        message += `\nUse ${this.agentInfo.config.commandPrefix}workflow to see steps`
-        message += `\nStart with ${this.agentInfo.config.commandPrefix}now to begin working`
-      }
-
       return {
         success: true,
-        message:
-          this.agent.formatResponse(message, 'idea') +
-          '\n' +
-          this.agent.suggestNextAction('ideaCaptured'),
+        designPath: designFilePath,
+        type: designType,
+        target: designTarget,
       }
     } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Show project recap with progress overview
-   *
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * Generate architecture design document
+   * @private
    */
-  async recap(projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+  _generateArchitectureDesign(target, projectPath) {
+    const projectName = path.basename(projectPath)
+    return `# Architecture Design: ${target}
 
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
-      }
+**Project**: ${projectName}
+**Created**: ${new Date().toLocaleString()}
+**Type**: System Architecture
 
-      const nowFilePath = await this.getFilePath(projectPath, 'core', 'now.md')
-      const nextFilePath = await this.getFilePath(projectPath, 'core', 'next.md')
-      const ideasFilePath = await this.getFilePath(projectPath, 'planning', 'ideas.md')
+## Overview
 
-      const nowFile = await this.agent.readFile(nowFilePath)
-      const nextFile = await this.agent.readFile(nextFilePath)
-      const ideasFile = await this.agent.readFile(ideasFilePath)
+High-level architecture design for ${target}.
 
-      const currentTask = nowFile.split('\n')[0].replace('# NOW: ', '').replace('# NOW', 'None')
+## Components
 
-      const queuedCount = (nextFile.match(/^- /gm) || []).length
-      const ideasCount = (ideasFile.match(/^- /gm) || []).length
+### Core Components
+1. **Component A**
+   - Responsibility: [Define responsibility]
+   - Dependencies: [List dependencies]
+   - Interfaces: [Define interfaces]
 
-      const config = await configManager.readConfig(projectPath)
-      let shippedCount = 0
-      let recentActivity = ''
+2. **Component B**
+   - Responsibility: [Define responsibility]
+   - Dependencies: [List dependencies]
+   - Interfaces: [Define interfaces]
 
-      if (config && config.projectId) {
-        const recentShips = await this.getHistoricalData(projectPath, 'month', 'shipped.md')
-        shippedCount = (recentShips.match(/✅/g) || []).length
+## Data Flow
 
-        const recentLogs = await this.getRecentLogs(projectPath, 7)
-        recentActivity = recentLogs
-          .slice(-3)
-          .map((entry) => {
-            return `• ${entry.action}: ${entry.data.task || entry.data.feature || entry.data.text || ''}`
-          })
-          .join('\n')
-      } else {
-        const shippedFilePath = await this.getFilePath(projectPath, 'progress', 'shipped.md')
-        const shippedFile = await this.agent.readFile(shippedFilePath)
-        shippedCount = (shippedFile.match(/✅/g) || []).length
-
-        const memoryFile = await this.getFilePath(projectPath, 'memory', 'memory.jsonl')
-        try {
-          const memory = await this.agent.readFile(memoryFile)
-          const lines = memory
-            .trim()
-            .split('\n')
-            .filter((l) => l)
-          recentActivity = lines
-            .slice(-3)
-            .map((l) => {
-              const entry = JSON.parse(l)
-              return `• ${entry.action}: ${entry.data.task || entry.data.feature || entry.data.text || ''}`
-            })
-            .join('\n')
-        } catch (e) {
-        }
-      }
-
-      const recapData = {
-        currentTask,
-        shippedCount,
-        queuedCount,
-        ideasCount,
-        recentActivity,
-      }
-
-      return {
-        success: true,
-        message: this.agent.formatRecap(recapData),
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
-    }
-  }
-
-  /**
-   * Show progress metrics for a time period
-   *
-   * @param {string} [period='week'] - Time period: 'day', 'week', or 'month'
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
-   */
-  async progress(period = 'week', projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+\`\`\`
+[User] → [Frontend] → [API Gateway] → [Backend Services] → [Database]
+                                    ↓
+                              [Cache Layer]
+\`\`\`
 
-      const shippedData = await this.getHistoricalData(projectPath, period, 'shipped.md')
+## Technology Stack
 
-      const features = []
-      const lines = shippedData.split('\n')
+- **Frontend**: [Framework/Library]
+- **Backend**: [Framework/Runtime]
+- **Database**: [Type/System]
+- **Deployment**: [Platform/Method]
 
-      for (const line of lines) {
-        if (line.includes('✅')) {
-          const match = line.match(/\*\*(.*?)\*\*.*?\((.*?)\)/)
-          if (match) {
-            features.push({
-              name: match[1],
-              date: new Date(match[2]),
-            })
-          }
-        }
-      }
+## Design Decisions
 
-      const now = new Date()
-      const periodDays = period === 'day' ? 1 : period === 'week' ? 7 : period === 'month' ? 30 : 7
-      const cutoff = new Date(now.getTime() - periodDays * 24 * 60 * 60 * 1000)
+### Decision 1: [Title]
+- **Context**: [Why this decision is needed]
+- **Options**: [Alternatives considered]
+- **Choice**: [What was chosen]
+- **Rationale**: [Why this choice]
 
-      const periodFeatures = features.filter((f) => f.date >= cutoff)
+## Implementation Plan
 
-      const timeMetrics = await this.getTimeMetrics(projectPath, period)
+1. [ ] Setup project structure
+2. [ ] Implement core components
+3. [ ] Add integration layer
+4. [ ] Testing and validation
+5. [ ] Documentation
 
-      const velocity = periodFeatures.length / periodDays
-      const previousVelocity = 0.3
+## Notes
 
-      const motivationalMessage =
-        velocity >= 0.5
-          ? 'Excellent momentum!'
-          : velocity >= 0.2
-            ? 'Good steady pace!'
-            : 'Time to ship more features!'
+[Additional notes, constraints, assumptions]
 
-      const progressData = {
-        period,
-        count: periodFeatures.length,
-        velocity,
-        previousVelocity,
-        recentFeatures: periodFeatures
-          .slice(0, 3)
-          .map((f) => `• ${f.name}`)
-          .join('\n'),
-        motivationalMessage,
-        timeMetrics,
-      }
-
-      return {
-        success: true,
-        message: this.agent.formatProgress(progressData),
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
-    }
+---
+*This is a living document. Update as design evolves.*
+`
   }
 
   /**
-   * Get time metrics from task completion logs
-   *
-   * @param {string} projectPath - Path to the project
-   * @param {string} period - Period ('day', 'week', 'month')
-   * @returns {Promise<Object>} Time metrics object
+   * Generate API design document
+   * @private
    */
-  async getTimeMetrics(projectPath, period) {
-    try {
-      const periodDays = period === 'day' ? 1 : period === 'week' ? 7 : period === 'month' ? 30 : 7
-      const logs = await sessionManager.getRecentLogs(await configManager.getProjectId(projectPath), periodDays, 'context.jsonl')
+  _generateApiDesign(target) {
+    return `# API Design: ${target}
 
-      const completedTasks = logs.filter(log => log.type === 'task_completed' && log.data?.duration)
+**Created**: ${new Date().toLocaleString()}
+**Type**: API Specification
 
-      if (completedTasks.length === 0) {
-        return {
-          totalTime: 'N/A',
-          avgDuration: 'N/A',
-          tasksCompleted: 0,
-          longestTask: 'N/A',
-          shortestTask: 'N/A',
-          byAuthor: {},
-        }
-      }
+## Endpoints
 
-      const parseDuration = (duration) => {
-        const match = duration.match(/(\d+)h (\d+)m/)
-        if (!match) return 0
-        return parseInt(match[1]) * 60 + parseInt(match[2])
-      }
+### GET /api/${target.toLowerCase()}
+**Description**: Retrieve ${target}
 
-      const durations = completedTasks.map(t => parseDuration(t.data.duration))
-      const totalMinutes = durations.reduce((sum, d) => sum + d, 0)
-      const avgMinutes = Math.round(totalMinutes / durations.length)
+**Request**:
+\`\`\`
+GET /api/${target.toLowerCase()}?limit=10&offset=0
+\`\`\`
 
-      const sortedDurations = [...durations].sort((a, b) => b - a)
-      const longestMinutes = sortedDurations[0]
-      const shortestMinutes = sortedDurations[sortedDurations.length - 1]
+**Response** (200 OK):
+\`\`\`json
+{
+  "data": [],
+  "meta": {
+    "total": 0,
+    "limit": 10,
+    "offset": 0
+  }
+}
+\`\`\`
 
-      const formatTime = (minutes) => {
-        const h = Math.floor(minutes / 60)
-        const m = minutes % 60
-        return `${h}h ${m}m`
-      }
+### POST /api/${target.toLowerCase()}
+**Description**: Create new ${target}
 
-      const byAuthor = {}
-      completedTasks.forEach(task => {
-        const author = task.data?.author || task.author || 'Unknown'
-        if (!byAuthor[author]) {
-          byAuthor[author] = {
-            tasks: 0,
-            totalMinutes: 0,
-          }
-        }
-        byAuthor[author].tasks++
-        byAuthor[author].totalMinutes += parseDuration(task.data.duration)
-      })
+**Request**:
+\`\`\`json
+{
+  "name": "string",
+  "description": "string"
+}
+\`\`\`
 
-      Object.keys(byAuthor).forEach(author => {
-        byAuthor[author].totalTime = formatTime(byAuthor[author].totalMinutes)
-        byAuthor[author].avgTime = formatTime(Math.round(byAuthor[author].totalMinutes / byAuthor[author].tasks))
-      })
+**Response** (201 Created):
+\`\`\`json
+{
+  "id": "string",
+  "name": "string",
+  "description": "string",
+  "createdAt": "ISO8601"
+}
+\`\`\`
 
-      return {
-        totalTime: formatTime(totalMinutes),
-        avgDuration: formatTime(avgMinutes),
-        tasksCompleted: completedTasks.length,
-        longestTask: formatTime(longestMinutes),
-        shortestTask: formatTime(shortestMinutes),
-        byAuthor,
-      }
-    } catch (error) {
-      return {
-        totalTime: 'N/A',
-        avgDuration: 'N/A',
-        tasksCompleted: 0,
-        longestTask: 'N/A',
-        shortestTask: 'N/A',
-        byAuthor: {},
-      }
-    }
-  }
+## Error Handling
 
-  /**
-   * Get help when stuck on a problem
-   *
-   * @param {string} issue - Issue description
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
-   */
-  async stuck(issue, projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+\`\`\`json
+{
+  "error": {
+    "code": "ERROR_CODE",
+    "message": "Human-readable message",
+    "details": {}
+  }
+}
+\`\`\`
 
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
-      }
+## Authentication
 
-      if (!issue) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            `Please describe what you're stuck on: ${this.agentInfo.config.commandPrefix}stuck "issue description"`,
-            'warning',
-          ),
-        }
-      }
+- **Method**: Bearer Token
+- **Header**: \`Authorization: Bearer <token>\`
 
-      await this.logToMemory(projectPath, 'stuck', { issue, timestamp: this.agent.getTimestamp() })
+## Rate Limiting
 
-      const helpContent = this.agent.getHelpContent(issue)
+- **Limit**: 100 requests/minute
+- **Headers**: \`X-RateLimit-Limit\`, \`X-RateLimit-Remaining\`
 
-      return {
-        success: true,
-        message: helpContent + '\n' + this.agent.suggestNextAction('stuck'),
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
-    }
+---
+*Update this specification as API evolves.*
+`
   }
 
   /**
-   * Advanced cleanup with multiple cleanup types
-   *
-   * @param {string} [target='.'] - Target directory
-   * @param {Object} [options={}] - Cleanup options
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * Generate component design document
+   * @private
    */
-  async cleanupAdvanced(_target = '.', options = {}, _projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+  _generateComponentDesign(target) {
+    return `# Component Design: ${target}
+
+**Created**: ${new Date().toLocaleString()}
+**Type**: Component Specification
 
-      const type = options.type || 'all'
-      const mode = options.aggressive ? 'aggressive' : 'safe'
-      const dryRun = options.dryRun || false
+## Overview
 
-      const results = {
-        deadCode: { consoleLogs: 0, commented: 0, unused: 0 },
-        imports: { removed: 0, organized: 0 },
-        files: { temp: 0, empty: 0, spaceFeed: 0 },
-        deps: { removed: 0, sizeSaved: 0 },
-      }
+Component for ${target} functionality.
 
-      if (type === 'all' || type === 'code') {
-        results.deadCode.consoleLogs = Math.floor(Math.random() * 20)
-        results.deadCode.commented = Math.floor(Math.random() * 10)
-        if (mode === 'aggressive') {
-          results.deadCode.unused = Math.floor(Math.random() * 5)
-        }
-      }
+## Props/Interface
 
-      if (type === 'all' || type === 'imports') {
-        results.imports.removed = Math.floor(Math.random() * 15)
-        results.imports.organized = Math.floor(Math.random() * 30)
-      }
+\`\`\`typescript
+interface ${target}Props {
+  // Define props
+  id?: string
+  className?: string
+  onAction?: (data: any) => void
+}
+\`\`\`
 
-      if (type === 'all' || type === 'files') {
-        results.files.temp = Math.floor(Math.random() * 10)
-        results.files.empty = Math.floor(Math.random() * 5)
-        results.files.spaceFeed = (Math.random() * 5).toFixed(1)
-      }
+## State
 
-      if (type === 'all' || type === 'deps') {
-        results.deps.removed = Math.floor(Math.random() * 6)
-        results.deps.sizeSaved = Math.floor(Math.random() * 20)
-      }
+\`\`\`typescript
+interface ${target}State {
+  // Define internal state
+  loading: boolean
+  data: any[]
+  error: Error | null
+}
+\`\`\`
 
-      if (animations) {
-        const message = `
-🧹 ✨ Advanced Cleanup Complete! ✨ 🧹
+## Component Structure
 
-📊 Cleanup Results:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+\`\`\`
+${target}/
+├── index.ts          # Barrel export
+├── ${target}.tsx     # Main component
+├── ${target}.test.tsx # Tests
+├── ${target}.styles.ts # Styles
+└── types.ts          # Type definitions
+\`\`\`
 
-🗑️ Dead Code Removed:
-• Console.logs: ${results.deadCode.consoleLogs} statements
-• Commented code: ${results.deadCode.commented} blocks
-${mode === 'aggressive' ? `• Unused functions: ${results.deadCode.unused}` : ''}
+## Usage Example
 
-📦 Imports Optimized:
-• Unused imports: ${results.imports.removed} removed
-• Files organized: ${results.imports.organized}
+\`\`\`tsx
+import { ${target} } from '@/components/${target}'
 
-📁 Files Cleaned:
-• Temp files: ${results.files.temp} removed
-• Empty files: ${results.files.empty} removed
-• Space freed: ${results.files.spaceFeed} MB
+function App() {
+  return (
+    <${target}
+      id="example"
+      onAction={(data) => console.log(data)}
+    />
+  )
+}
+\`\`\`
 
-📚 Dependencies:
-• Unused packages: ${results.deps.removed} removed
-• Size reduced: ${results.deps.sizeSaved} MB
+## Dependencies
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✨ Your code is clean and optimized!
+- React
+- [Other libraries]
 
-${dryRun ? '⚠️ DRY RUN - No changes were made' : '✅ All changes applied successfully'}
-💡 Tip: Run with --dry-run first to preview changes`
+## Implementation Notes
 
-        return {
-          success: true,
-          message,
-        }
-      }
+1. [ ] Setup component structure
+2. [ ] Implement core logic
+3. [ ] Add styling
+4. [ ] Write tests
+5. [ ] Document usage
 
-      return {
-        success: true,
-        message: this.agent.formatResponse('Advanced cleanup complete!', 'success'),
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
-    }
+---
+*Component design is iterative. Update as needed.*
+`
   }
 
   /**
-   * Generate design documents and diagrams
-   *
-   * @param {string} target - Design target name
-   * @param {Object} [options={}] - Design options
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * Generate database design document
+   * @private
    */
-  async design(target, options = {}, projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+  _generateDatabaseDesign(target) {
+    return `# Database Design: ${target}
 
-      // Verify project is initialized
-      if (!await configManager.isConfigured(projectPath)) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            `Project not initialized. Run ${this.agentInfo.config.commandPrefix}init first.`,
-            'warning'
-          ),
-        }
-      }
+**Created**: ${new Date().toLocaleString()}
+**Type**: Database Schema
 
-      const type = options.type || 'architecture'
+## Schema
 
-      // Use global architecture
-      const projectId = await configManager.getProjectId(projectPath)
-      const globalPath = pathManager.getGlobalProjectPath(projectId)
-      const designDir = path.join(globalPath, 'analysis', 'designs')
-      await this.agent.createDirectory(designDir)
+### Table: ${target.toLowerCase()}
 
-      let designContent = ''
-      let diagram = ''
+\`\`\`sql
+CREATE TABLE ${target.toLowerCase()} (
+  id SERIAL PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  description TEXT,
+  status VARCHAR(50) DEFAULT 'active',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+\`\`\`
 
-      switch (type) {
-        case 'architecture':
-          diagram = `
-┌─────────────┐     ┌─────────────┐     ┌─────────────┐
-│   Frontend  │────▶│   Backend   │────▶│  Database   │
-│    React    │     │   Node.js   │     │  PostgreSQL │
-└─────────────┘     └─────────────┘     └─────────────┘
-       │                   │                    │
-       ▼                   ▼                    ▼
-┌─────────────┐     ┌─────────────┐     ┌─────────────┐
-│    Redux    │     │   Express   │     │    Redis    │
-│    Store    │     │   Routes    │     │    Cache    │
-└─────────────┘     └─────────────┘     └─────────────┘`
-          break
+## Indexes
 
-        case 'api':
-          diagram = `
-REST API Endpoints:
-POST   /api/auth/register
-POST   /api/auth/login
-GET    /api/users/:id
-PUT    /api/users/:id
-DELETE /api/users/:id`
-          break
+\`\`\`sql
+CREATE INDEX idx_${target.toLowerCase()}_status ON ${target.toLowerCase()}(status);
+CREATE INDEX idx_${target.toLowerCase()}_created_at ON ${target.toLowerCase()}(created_at);
+\`\`\`
 
-        case 'component':
-          diagram = `
-<App>
-├── <Header>
-│   ├── <Logo />
-│   ├── <Navigation />
-│   └── <UserMenu />
-├── <Main>
-│   ├── <Sidebar />
-│   └── <Content>
-│       ├── <Dashboard />
-│       └── <Routes />
-└── <Footer>`
-          break
+## Relationships
 
-        case 'database':
-          diagram = `
-┌─────────────┐     ┌─────────────┐
-│    users    │────▶│   profiles  │
-├─────────────┤     ├─────────────┤
-│ id (PK)     │     │ id (PK)     │
-│ email       │     │ user_id(FK) │
-│ password    │     │ bio         │
-│ created_at  │     │ avatar_url  │
-└─────────────┘     └─────────────┘`
-          break
+- **Related Tables**: [List related tables]
+- **Foreign Keys**: [Define foreign keys]
 
-        default:
-          diagram = 'Custom design diagram'
-      }
+## Queries
 
-      const timestamp = new Date().toISOString().split('T')[0]
-      const designFile = path.join(designDir, `${target.replace(/\s+/g, '-')}-${type}-${timestamp}.md`)
+### Common Queries
 
-      designContent = `# Design: ${target}
-Type: ${type}
-Date: ${timestamp}
+\`\`\`sql
+-- Get active records
+SELECT * FROM ${target.toLowerCase()} WHERE status = 'active';
 
-## Architecture Diagram
-\`\`\`
-${diagram}
+-- Get recent records
+SELECT * FROM ${target.toLowerCase()}
+ORDER BY created_at DESC
+LIMIT 10;
 \`\`\`
 
-## Technical Specifications
-- Technology Stack: Modern web stack
-- Design Patterns: MVC, Repository, Observer
-- Key Components: Authentication, API, Database
-- Data Flow: Request → Controller → Service → Database
-
-## Implementation Guide
-1. Set up project structure
-2. Implement core models
-3. Build API endpoints
-4. Create UI components
-5. Add tests and documentation
+## Migrations
+
+1. [ ] Create initial schema
+2. [ ] Add indexes
+3. [ ] Setup relationships
+4. [ ] Add constraints
+
+## Notes
+
+- Consider partitioning for large datasets
+- Add audit logging if needed
+- Implement soft deletes
+
+---
+*Database design should evolve with requirements.*
 `
+  }
 
-      await this.agent.writeFile(designFile, designContent)
+  /**
+   * Generate flow design document
+   * @private
+   */
+  _generateFlowDesign(target) {
+    return `# Flow Design: ${target}
 
-      await this.logToMemory(projectPath, 'design', {
-        target,
-        type,
-        file: designFile,
-      })
+**Created**: ${new Date().toLocaleString()}
+**Type**: Process Flow
 
-      const message = `
-🎨 ✨ Design Complete! ✨ 🎨
+## Flow Overview
 
-📐 Design: ${target}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Process flow for ${target}.
 
-🏗️ Architecture Overview:
-${diagram}
+## Steps
 
-📋 Technical Specifications:
-• Technology Stack: Modern web stack
-• Design Patterns: MVC, Repository
-• Key Components: Listed in design doc
-• Data Flow: Documented
+\`\`\`
+1. [User Action/Trigger]
+   ↓
+2. [Validation]
+   ↓
+3. [Processing]
+   ↓
+4. [Side Effects]
+   ↓
+5. [Response/Completion]
+\`\`\`
 
-📁 Files Created:
-• ${designFile}
+## Detailed Flow
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✅ Design ready for implementation!
+### Step 1: Initial Action
+- **Input**: [What triggers this]
+- **Validation**: [What gets checked]
+- **Output**: [What proceeds]
 
-💡 Next: prjct now "Implement ${target}"`
+### Step 2: Processing
+- **Actions**: [What happens]
+- **Dependencies**: [What's needed]
+- **Side Effects**: [What changes]
 
-      return {
-        success: true,
-        message,
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
-    }
+### Step 3: Completion
+- **Success**: [What happens on success]
+- **Failure**: [What happens on failure]
+- **Notifications**: [Who gets notified]
+
+## Error Handling
+
+- **Error Type 1**: [Recovery strategy]
+- **Error Type 2**: [Recovery strategy]
+
+## Rollback Strategy
+
+[How to undo if needed]
+
+## Monitoring
+
+- **Metrics**: [What to track]
+- **Alerts**: [When to alert]
+
+---
+*Document edge cases and special scenarios.*
+`
   }
 
   /**
-   * Show project context and recent activity
-   *
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * /p:cleanup - Clean temp files and old entries
+   * AGENTIC EXECUTION
    */
-  async context(projectPath = process.cwd()) {
+  async cleanup(_options = {}, projectPath = process.cwd()) {
     try {
-      await this.initializeAgent()
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
-      }
+      console.log('🧹 Cleaning up project...\n')
 
-      const projectInfo = await this.detectProjectType(projectPath)
+      const context = await contextBuilder.build(projectPath)
+      const projectId = await configManager.getProjectId(projectPath)
 
-      const nowFilePath = await this.getFilePath(projectPath, 'core', 'now.md')
-      const nowFile = await this.agent.readFile(nowFilePath)
-      const currentTask = nowFile.split('\n')[0].replace('# NOW: ', '').replace('# NOW', 'None')
+      const cleaned = []
 
-      const config = await configManager.readConfig(projectPath)
-      let recentActions = []
+      // Clean old memory entries (keep last 100)
+      const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
+      try {
+        const entries = await jsonlHelper.readJsonLines(memoryPath)
 
-      if (config && config.projectId) {
-        const recentLogs = await this.getRecentLogs(projectPath, 7)
-        recentActions = recentLogs.slice(-5).map((entry) => {
-          return `• ${entry.action}: ${entry.data.task || entry.data.feature || entry.data.text || ''}`
-        })
-      } else {
-        const memoryFile = await this.getFilePath(projectPath, 'memory', 'memory.jsonl')
-        try {
-          const memory = await this.agent.readFile(memoryFile)
-          const lines = memory
+        if (entries.length > 100) {
+          const kept = entries.slice(-100)
+          await jsonlHelper.writeJsonLines(memoryPath, kept)
+          cleaned.push(`Memory: ${entries.length - 100} old entries removed`)
+        } else {
+          cleaned.push('Memory: No cleanup needed')
+        }
+      } catch {
+        cleaned.push('Memory: No file found')
+      }
+
+      // Clean empty ideas sections
+      const ideasPath = context.paths.ideas
+      try {
+        const ideasContent = await toolRegistry.get('Read')(ideasPath)
+        const sections = ideasContent.split('##').filter((s) => s.trim())
+
+        // Remove empty sections
+        const nonEmpty = sections.filter((section) => {
+          const lines = section
             .trim()
             .split('\n')
-            .filter((l) => l)
-          recentActions = lines.slice(-5).map((l) => {
-            const entry = JSON.parse(l)
-            return `• ${entry.action}: ${entry.data.task || entry.data.feature || entry.data.text || ''}`
-          })
-        } catch (e) {
+            .filter((l) => l.trim())
+          return lines.length > 1 // Keep if has more than just title
+        })
+
+        if (sections.length !== nonEmpty.length) {
+          const newContent =
+            '# IDEAS 💡\n\n## Brain Dump\n\n' +
+            nonEmpty
+              .slice(1)
+              .map((s) => '## ' + s.trim())
+              .join('\n\n')
+          await toolRegistry.get('Write')(ideasPath, newContent)
+          cleaned.push(`Ideas: ${sections.length - nonEmpty.length} empty sections removed`)
+        } else {
+          cleaned.push('Ideas: No cleanup needed')
         }
+      } catch {
+        cleaned.push('Ideas: No file found')
       }
 
-      const contextInfo =
-        'Project Context\n\n' +
-        `Agent: ${this.agentInfo.name}\n` +
-        `Project: ${projectInfo}\n` +
-        `Current: ${currentTask}\n\n` +
-        `Recent actions:\n${recentActions.join('\n') || '• No recent actions'}\n\n` +
-        `Use ${this.agentInfo.config.commandPrefix}recap for full progress report`
+      // Clean completed tasks from next.md (optional - user decides)
+      const nextPath = context.paths.next
+      try {
+        const nextContent = await toolRegistry.get('Read')(nextPath)
+        const completedTasks = (nextContent.match(/\[x\]/gi) || []).length
 
-      return {
-        success: true,
-        message: this.agent.formatResponse(contextInfo, 'info'),
+        if (completedTasks > 0) {
+          cleaned.push(
+            `Queue: ${completedTasks} completed tasks found (not removed - use /p:done to clear)`
+          )
+        } else {
+          cleaned.push('Queue: No completed tasks')
+        }
+      } catch {
+        cleaned.push('Queue: No file found')
       }
+
+      console.log('✅ Cleanup complete!\n')
+      cleaned.forEach((item) => console.log(`   • ${item}`))
+
+      await this.logToMemory(projectPath, 'cleanup_performed', {
+        items: cleaned.length,
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      return { success: true, cleaned }
     } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(error.message, 'error'),
-      }
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Detect project type from package.json and files
-   *
-   * @param {string} projectPath - Project path
-   * @returns {Promise<string>} Project type description
+   * /p:progress - Show metrics for period
+   * AGENTIC EXECUTION
    */
-  async detectProjectType(projectPath) {
-    const files = await fs.readdir(projectPath)
+  async progress(period = 'week', projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-    if (files.includes('package.json')) {
-      try {
-        const pkg = JSON.parse(await fs.readFile(path.join(projectPath, 'package.json'), 'utf-8'))
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies }
-
-        if (deps.next) return 'Next.js project'
-        if (deps.react) return 'React project'
-        if (deps.vue) return 'Vue project'
-        if (deps.express) return 'Express project'
-        return 'Node.js project'
-      } catch (e) {
-        return 'Node.js project'
+      const validPeriods = ['day', 'week', 'month', 'all']
+      if (!validPeriods.includes(period)) {
+        period = 'week'
       }
-    }
 
-    if (files.includes('Cargo.toml')) return 'Rust project'
-    if (files.includes('go.mod')) return 'Go project'
-    if (files.includes('requirements.txt')) return 'Python project'
-    if (files.includes('Gemfile')) return 'Ruby project'
+      console.log(`📈 Progress Report (${period})\n`)
 
-    return 'General project'
-  }
+      const projectId = await configManager.getProjectId(projectPath)
+      const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
 
-  /**
-   * Get week number from date
-   *
-   * @param {Date} date - Date to get week number for
-   * @returns {number} Week number
-   */
-  getWeekNumber(date) {
-    const firstDayOfYear = new Date(date.getFullYear(), 0, 1)
-    const pastDaysOfYear = (date - firstDayOfYear) / 86400000
-    return Math.ceil((pastDaysOfYear + firstDayOfYear.getDay() + 1) / 7)
-  }
+      // Calculate time range
+      const now = new Date()
+      let startDate
 
-  /**
-   * Get days since last ship event
-   *
-   * @param {string} projectPath - Project path
-   * @returns {Promise<number>} Days since last ship or Infinity if never shipped
-   */
-  async getDaysSinceLastShip(projectPath) {
-    try {
-      await this.initializeAgent()
+      switch (period) {
+        case 'day':
+          startDate = dateHelper.getDaysAgo(1)
+          break
+        case 'week':
+          startDate = dateHelper.getDaysAgo(7)
+          break
+        case 'month':
+          startDate = dateHelper.getDaysAgo(30)
+          break
+        case 'all':
+          startDate = new Date(0) // Beginning of time
+          break
+      }
 
-      // Use global architecture
-      const projectId = await configManager.getProjectId(projectPath)
-      const globalPath = pathManager.getGlobalProjectPath(projectId)
-      const memoryFile = path.join(globalPath, 'memory', 'context.jsonl')
-      const memory = await this.agent.readFile(memoryFile)
-      const lines = memory
-        .trim()
-        .split('\n')
-        .filter((l) => l)
-
-      for (let i = lines.length - 1; i >= 0; i--) {
-        const entry = JSON.parse(lines[i])
-        if (entry.action === 'ship') {
-          const shipDate = new Date(entry.data.timestamp)
-          const now = new Date()
-          return Math.floor((now - shipDate) / 86400000)
-        }
+      // Read memory and filter by period
+      let entries = []
+      try {
+        const allEntries = await jsonlHelper.readJsonLines(memoryPath)
+
+        entries = allEntries.filter((entry) => {
+          const entryDate = new Date(entry.timestamp)
+          return entryDate >= startDate
+        })
+      } catch {
+        entries = []
+      }
+
+      // Calculate metrics
+      const metrics = {
+        tasksStarted: entries.filter((e) => e.action === 'task_started').length,
+        tasksCompleted: entries.filter((e) => e.action === 'task_completed').length,
+        featuresPlanned: entries.filter((e) => e.action === 'feature_planned').length,
+        featuresShipped: entries.filter((e) => e.action === 'feature_shipped').length,
+        bugsReported: entries.filter((e) => e.action === 'bug_reported').length,
+        designsCreated: entries.filter((e) => e.action === 'design_created').length,
+        helpRequested: entries.filter((e) => e.action === 'help_requested').length,
+        totalActions: entries.length,
       }
-    } catch (e) {
+
+      // Display metrics
+      console.log('═══════════════════════════════════════════════════')
+      console.log(
+        `  Period: ${period} (${startDate.toLocaleDateString()} - ${now.toLocaleDateString()})`
+      )
+      console.log('═══════════════════════════════════════════════════\n')
+
+      console.log('## Activity Summary\n')
+      console.log(`   Total Actions: ${metrics.totalActions}`)
+      console.log(`   Tasks Started: ${metrics.tasksStarted}`)
+      console.log(`   Tasks Completed: ${metrics.tasksCompleted}`)
+      console.log(`   Features Planned: ${metrics.featuresPlanned}`)
+      console.log(`   Features Shipped: ${metrics.featuresShipped}`)
+      console.log(`   Bugs Reported: ${metrics.bugsReported}`)
+      console.log(`   Designs Created: ${metrics.designsCreated}`)
+      console.log(`   Help Requested: ${metrics.helpRequested}\n`)
+
+      // Completion rate
+      if (metrics.tasksStarted > 0) {
+        const completionRate = Math.round((metrics.tasksCompleted / metrics.tasksStarted) * 100)
+        console.log(`## Completion Rate: ${completionRate}%\n`)
+      }
+
+      // Velocity
+      const daysInPeriod =
+        period === 'day' ? 1 : period === 'week' ? 7 : period === 'month' ? 30 : 365
+      const tasksPerDay = (metrics.tasksCompleted / daysInPeriod).toFixed(1)
+      console.log(`## Velocity: ${tasksPerDay} tasks/day\n`)
+
+      console.log('💡 Actions:')
+      console.log('• /p:recap → See shipped features')
+      console.log('• /p:context → View current state')
+      console.log('• /p:progress day|week|month|all → Change period')
+
+      await this.logToMemory(projectPath, 'progress_viewed', {
+        period,
+        metrics,
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      return { success: true, period, metrics }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
-    return Infinity
   }
 
   /**
-   * Log action to memory system
-   *
-   * @param {string} projectPath - Project path
-   * @param {string} action - Action type
-   * @param {Object} data - Action data
+   * /p:roadmap - Show roadmap with ASCII logic maps
+   * AGENTIC EXECUTION
    */
-  async logToMemory(projectPath, action, data) {
-    await this.initializeAgent()
-    await this.ensureAuthor()
+  async roadmap(projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-    const config = await configManager.readConfig(projectPath)
+      console.log('🗺️  Project Roadmap\n')
 
-    if (config && config.projectId) {
-      const entry = {
-        action,
-        author: this.currentAuthor,
-        data,
-        timestamp: new Date().toISOString(),
-      }
+      const context = await contextBuilder.build(projectPath)
 
-      try {
-        await sessionManager.writeToSession(config.projectId, entry, 'context.jsonl')
-      } catch (error) {
-        console.error('Session logging failed, falling back to legacy:', error.message)
-        await this._logToMemoryLegacy(projectPath, action, data)
+      // Read roadmap content
+      const roadmapContent = await toolRegistry.get('Read')(context.paths.roadmap)
+
+      if (!roadmapContent || roadmapContent.trim() === '# ROADMAP') {
+        console.log('📝 No roadmap yet. Add features to build roadmap:\n')
+        console.log('Example roadmap structure:')
+        console.log(this._generateRoadmapTemplate())
+        console.log('\n💡 Use /p:feature to add features')
+        console.log('   Features are automatically added to roadmap')
+        return { success: true, message: 'No roadmap' }
       }
-    } else {
-      await this._logToMemoryLegacy(projectPath, action, data)
+
+      // Display roadmap
+      console.log(roadmapContent)
+
+      console.log('\n💡 Actions:')
+      console.log('• /p:feature → Add new feature to roadmap')
+      console.log('• /p:status → See implementation status')
+
+      await this.logToMemory(projectPath, 'roadmap_viewed', {
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      return { success: true, content: roadmapContent }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Legacy logging method (fallback)
-   *
+   * Generate roadmap template
    * @private
-   * @param {string} projectPath - Project path
-   * @param {string} action - Action type
-   * @param {Object} data - Action data
    */
-  async _logToMemoryLegacy(projectPath, action, data) {
-    const memoryFile = await this.getFilePath(projectPath, 'memory', 'context.jsonl')
-    const entry = JSON.stringify({
-      action,
-      author: this.currentAuthor,
-      data,
-      timestamp: new Date().toISOString(),
-    }) + '\n'
+  _generateRoadmapTemplate() {
+    return `
+# ROADMAP
 
-    try {
-      const existingContent = await this.agent.readFile(memoryFile)
-      await this.agent.writeFile(memoryFile, existingContent + entry)
-    } catch (e) {
-      await this.agent.writeFile(memoryFile, entry)
-    }
+## Q1 2025 - Foundation
+
+\`\`\`
+[Authentication] ──┐
+                   ├──> [User Management] ──> [Dashboard]
+[Database Setup] ──┘
+\`\`\`
+
+Status: 🟢 In Progress
+
+## Q2 2025 - Core Features
+
+\`\`\`
+[API v1] ──┐
+           ├──> [Integration] ──> [Beta Launch]
+[UI v2] ───┘
+\`\`\`
+
+Status: ⏸️  Planned
+
+## Dependencies
+
+- Authentication → User Management
+- Database Setup → Authentication
+- API v1 + UI v2 → Integration
+`
   }
 
   /**
-   * Get historical data from sessions
-   * Consolidates data from multiple sessions based on time period
-   *
-   * @param {string} projectPath - Project path
-   * @param {string} [period='week'] - Time period: 'day', 'week', 'month', 'all'
-   * @param {string} [filename='context.jsonl'] - File to read from sessions
-   * @returns {Promise<Array<Object>>} Consolidated entries
+   * /p:status - KPI dashboard with ASCII graphics
+   * AGENTIC EXECUTION
    */
-  async getHistoricalData(projectPath, period = 'week', filename = 'context.jsonl') {
-    const config = await configManager.readConfig(projectPath)
-
-    if (!config || !config.projectId) {
-      return await this._getHistoricalDataLegacy(projectPath, filename)
-    }
-
-    const toDate = new Date()
-    const fromDate = new Date()
-    const isMarkdown = filename.endsWith('.md')
-
-    switch (period) {
-      case 'day':
-      case 'today':
-        if (isMarkdown) {
-          const sessionPath = await pathManager.getCurrentSessionPath(config.projectId)
-          const filePath = path.join(sessionPath, filename)
-          try {
-            return await fs.readFile(filePath, 'utf-8')
-          } catch {
-            return ''
-          }
-        }
-        return await sessionManager.readCurrentSession(config.projectId, filename)
+  async status(projectPath = process.cwd()) {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      console.log('📊 Project Status Dashboard\n')
+
+      const context = await contextBuilder.build(projectPath)
+
+      // Read project data
+      const nowContent = await toolRegistry.get('Read')(context.paths.now)
+      const nextContent = await toolRegistry.get('Read')(context.paths.next)
+      const shippedContent = await toolRegistry.get('Read')(context.paths.shipped)
+      const ideasContent = await toolRegistry.get('Read')(context.paths.ideas)
+
+      // Calculate stats
+      const stats = {
+        activeTask: nowContent && !nowContent.includes('No current task'),
+        tasksInQueue:
+          nextContent
+            ?.split('\n')
+            .filter((line) => line.trim().match(/^\d+\./) || line.includes('[ ]')).length || 0,
+        featuresShipped:
+          shippedContent
+            ?.split('##')
+            .filter((section) => section.trim() && !section.includes('SHIPPED 🚀')).length || 0,
+        ideasCaptured:
+          ideasContent
+            ?.split('##')
+            .filter(
+              (section) =>
+                section.trim() && !section.includes('IDEAS 💡') && !section.includes('Brain Dump')
+            ).length || 0,
+      }
+
+      // Header
+      console.log('═══════════════════════════════════════════════════')
+      console.log(`  ${path.basename(projectPath)} - Status Overview`)
+      console.log('═══════════════════════════════════════════════════\n')
+
+      // Current Focus
+      console.log('## 🎯 Current Focus\n')
+      if (stats.activeTask) {
+        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const task = taskMatch ? taskMatch[1] : 'Active task'
+        const startedMatch = nowContent.match(/Started: (.+)/)
+        const started = startedMatch ? startedMatch[1] : 'Unknown'
+        console.log(`   📌 ${task}`)
+        console.log(`   ⏱️  Started: ${started}\n`)
+      } else {
+        console.log('   No active task\n')
+      }
 
-      case 'week':
-        fromDate.setDate(fromDate.getDate() - 7)
-        break
+      // Queue Status
+      console.log('## 📋 Queue Status\n')
+      console.log(`   Tasks in Queue: ${stats.tasksInQueue}`)
+      this._renderProgressBar('Queue Load', stats.tasksInQueue, 20)
+      console.log('')
 
-      case 'month':
-        fromDate.setMonth(fromDate.getMonth() - 1)
-        break
+      // Shipped Features
+      console.log('## 🚀 Shipped Features\n')
+      console.log(`   Features Shipped: ${stats.featuresShipped}`)
+      this._renderProgressBar('Progress', stats.featuresShipped, 10)
+      console.log('')
 
-      case 'all':
-        fromDate.setFullYear(fromDate.getFullYear() - 1)
-        break
+      // Ideas Backlog
+      console.log('## 💡 Ideas Backlog\n')
+      console.log(`   Ideas Captured: ${stats.ideasCaptured}`)
+      this._renderProgressBar('Backlog', stats.ideasCaptured, 15)
+      console.log('')
 
-      default:
-        fromDate.setDate(fromDate.getDate() - 7)
-    }
+      // Overall Health
+      console.log('## 💚 Overall Health\n')
+      const health = this._calculateHealth(stats)
+      console.log(`   Health Score: ${health.score}/100`)
+      this._renderProgressBar('Health', health.score, 100)
+      console.log(`   ${health.message}\n`)
+
+      console.log('💡 Next steps:')
+      console.log('• /p:now → Start working on a task')
+      console.log('• /p:feature → Add new feature')
+      console.log('• /p:ship → Ship completed work')
+
+      await this.logToMemory(projectPath, 'status_viewed', {
+        stats,
+        health: health.score,
+        timestamp: dateHelper.getTimestamp(),
+      })
 
-    if (isMarkdown) {
-      return await sessionManager.readMarkdownRange(config.projectId, fromDate, toDate, filename)
-    } else {
-      return await sessionManager.readSessionRange(config.projectId, fromDate, toDate, filename)
+      return { success: true, stats, health }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Get historical data from legacy single-file structure
-   *
+   * Render ASCII progress bar
    * @private
-   * @param {string} projectPath - Project path
-   * @param {string} filename - Filename to read
-   * @returns {Promise<Array<Object>>} Parsed entries
    */
-  async _getHistoricalDataLegacy(projectPath, filename) {
-    const filePath = await this.getFilePath(projectPath, 'memory', filename)
-
-    try {
-      const content = await this.agent.readFile(filePath)
-      const lines = content.split('\n').filter(line => line.trim())
-      return lines.map(line => {
-        try {
-          return JSON.parse(line)
-        } catch {
-          return null
-        }
-      }).filter(Boolean)
-    } catch {
-      return []
-    }
+  _renderProgressBar(label, value, max) {
+    const percentage = Math.min(100, Math.round((value / max) * 100))
+    const barLength = 30
+    const filled = Math.round((percentage / 100) * barLength)
+    const empty = barLength - filled
+
+    const bar = '█'.repeat(filled) + '░'.repeat(empty)
+    console.log(`   ${label}: [${bar}] ${percentage}%`)
   }
 
   /**
-   * Get recent logs with session support
-   *
-   * @param {string} projectPath - Project path
-   * @param {number} [days=7] - Number of days to look back
-   * @returns {Promise<Array<Object>>} Recent log entries
+   * Calculate project health score
+   * @private
    */
-  async getRecentLogs(projectPath, days = 7) {
-    const config = await configManager.readConfig(projectPath)
+  _calculateHealth(stats) {
+    let score = 50 // Base score
 
-    if (config && config.projectId) {
-      return await sessionManager.getRecentLogs(config.projectId, days)
-    } else {
-      return await this._getHistoricalDataLegacy(projectPath, 'context.jsonl')
-    }
+    // Active task is good
+    if (stats.activeTask) score += 20
+
+    // Having tasks but not too many
+    if (stats.tasksInQueue > 0 && stats.tasksInQueue < 15) score += 15
+    if (stats.tasksInQueue >= 15) score -= 5 // Too many tasks
+
+    // Shipped features is great
+    score += Math.min(20, stats.featuresShipped * 5)
+
+    // Ideas are good but not critical
+    score += Math.min(10, stats.ideasCaptured * 2)
+
+    score = Math.max(0, Math.min(100, score))
+
+    let message = ''
+    if (score >= 80) message = '🟢 Excellent - Great momentum!'
+    else if (score >= 60) message = '🟡 Good - Keep shipping!'
+    else if (score >= 40) message = '🟠 Fair - Need more activity'
+    else message = '🔴 Low - Time to get started!'
+
+    return { score, message }
   }
 
   /**
-   * Cleanup old project data
-   *
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
+   * /p:build - Start task with agent assignment
+   * AGENTIC EXECUTION
    */
-  async cleanup(projectPath = process.cwd()) {
+  async build(taskOrNumber, projectPath = process.cwd()) {
     try {
-      await this.initializeAgent()
-
-      // Verify project is initialized
-      if (!await configManager.isConfigured(projectPath)) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            `Project not initialized. Run ${this.agentInfo.config.commandPrefix}init first.`,
-            'warning'
-          ),
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const context = await contextBuilder.build(projectPath, { task: taskOrNumber })
+
+      // Check if already working on something
+      const nowContent = await toolRegistry.get('Read')(context.paths.now)
+      if (nowContent && !nowContent.includes('No current task')) {
+        console.log('⚠️  Already working on a task!')
+        console.log('   Complete it with /p:done first\n')
+        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const currentTask = taskMatch ? taskMatch[1] : 'current task'
+        console.log(`   Current: ${currentTask}`)
+        return { success: false, message: 'Task already active' }
+      }
+
+      let task = taskOrNumber
+
+      // If number, get from queue
+      if (!isNaN(taskOrNumber)) {
+        const nextContent = await toolRegistry.get('Read')(context.paths.next)
+        const tasks = nextContent
+          .split('\n')
+          .filter((line) => line.trim().match(/^\d+\./) || line.includes('[ ]'))
+
+        const index = parseInt(taskOrNumber) - 1
+        if (index >= 0 && index < tasks.length) {
+          task = tasks[index].replace(/^\d+\.\s*\[.\]\s*/, '').trim()
+          console.log(`📋 Selected from queue: ${task}\n`)
+        } else {
+          console.log(`❌ Invalid task number. Queue has ${tasks.length} tasks.`)
+          console.log('   Use /p:next to see queue')
+          return { success: false, error: 'Invalid task number' }
         }
       }
 
-      // Use global architecture
-      const projectId = await configManager.getProjectId(projectPath)
-      const globalPath = pathManager.getGlobalProjectPath(projectId)
+      if (!task) {
+        console.log('❌ Task description required')
+        console.log('Usage: /p:build "task description"')
+        console.log('   or: /p:build 1 (select from queue)')
+        return { success: false, error: 'Task required' }
+      }
 
-      let totalFreed = 0
-      let filesRemoved = 0
-      let tasksArchived = 0
+      console.log(`🏗️  Building: ${task}\n`)
 
-      try {
-        const tempDir = path.join(globalPath, 'temp')
-        const tempFiles = await fs.readdir(tempDir).catch(() => [])
-        for (const file of tempFiles) {
-          const filePath = path.join(tempDir, file)
-          const stats = await fs.stat(filePath)
-          totalFreed += stats.size
-          await fs.unlink(filePath)
-          filesRemoved++
-        }
-      } catch (e) {
-      }
+      // Detect complexity and estimate
+      const complexity = this._detectComplexity(task)
+      const estimate = complexity.hours
 
-      try {
-        const memoryFile = path.join(globalPath, 'memory', 'context.jsonl')
-        const content = await this.agent.readFile(memoryFile)
-        const lines = content.split('\n').filter(line => line.trim())
-        const now = new Date()
-        const thirtyDaysAgo = new Date(now.getTime() - 30 * 86400000)
-
-        const recentLines = []
-        const archivedLines = []
-
-        for (const line of lines) {
-          try {
-            const entry = JSON.parse(line)
-            const entryDate = new Date(entry.timestamp || entry.data?.timestamp)
-            if (entryDate > thirtyDaysAgo) {
-              recentLines.push(line)
-            } else {
-              archivedLines.push(line)
-            }
-          } catch {
-            recentLines.push(line)
-          }
-        }
+      console.log('📊 Analysis:')
+      console.log(`   Complexity: ${complexity.level}`)
+      console.log(`   Estimated: ${estimate}h`)
+      console.log(`   Type: ${complexity.type}\n`)
 
-        if (archivedLines.length > 0) {
-          const archiveFile = path.join(globalPath, 'memory', `archive-${now.toISOString().split('T')[0]}.jsonl`)
-          await this.agent.writeFile(archiveFile, archivedLines.join('\n') + '\n')
-          await this.agent.writeFile(memoryFile, recentLines.join('\n') + '\n')
-          tasksArchived = archivedLines.length
-        }
-      } catch (e) {
-      }
+      // Auto-assign agent (simplified)
+      const agent = this._autoAssignAgent(task)
+      console.log(`🤖 Agent: ${agent}\n`)
 
-      const files = await fs.readdir(globalPath)
-      for (const file of files) {
-        if (file.endsWith('.md') || file.endsWith('.txt')) {
-          const filePath = path.join(globalPath, file)
-          const stats = await fs.stat(filePath)
-          if (stats.size === 0) {
-            await fs.unlink(filePath)
-            filesRemoved++
-          }
-        }
-      }
+      // Set as current task with metadata
+      const nowContentNew = `# NOW
 
-      try {
-        const shippedFile = path.join(globalPath, 'progress', 'shipped.md')
-        const content = await this.agent.readFile(shippedFile)
-        const lines = content.split('\n')
-        const now = new Date()
-        const thirtyDaysAgo = new Date(now.getTime() - 30 * 86400000)
-
-        const filteredLines = lines.filter(line => {
-          if (line.includes('✅')) {
-            const dateMatch = line.match(/\((.*?)\)/)
-            if (dateMatch) {
-              const taskDate = new Date(dateMatch[1])
-              if (taskDate < thirtyDaysAgo) {
-                tasksArchived++
-                return false
-              }
-            }
-          }
-          return true
-        })
+**${task}**
 
-        await this.agent.writeFile(shippedFile, filteredLines.join('\n'))
-      } catch (e) {
-      }
+Started: ${new Date().toLocaleString()}
+Estimated: ${estimate}h
+Complexity: ${complexity.level}
+Agent: ${agent}
+`
+      await toolRegistry.get('Write')(context.paths.now, nowContentNew)
+
+      console.log('✅ Task started!\n')
+      console.log('💡 Next steps:')
+      console.log('• Start coding')
+      console.log('• /p:done → Mark complete')
+      console.log('• /p:stuck → Get help if needed')
+
+      await this.logToMemory(projectPath, 'task_built', {
+        task,
+        complexity: complexity.level,
+        estimate,
+        agent,
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      return { success: true, task, complexity, estimate, agent }
+    } catch (error) {
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
+    }
+  }
+
+  /**
+   * Detect task complexity
+   * @private
+   */
+  _detectComplexity(task) {
+    const lowerTask = task.toLowerCase()
+
+    // Type detection
+    let type = 'general'
+    if (lowerTask.includes('fix') || lowerTask.includes('bug')) type = 'bugfix'
+    else if (lowerTask.includes('test')) type = 'testing'
+    else if (lowerTask.includes('refactor')) type = 'refactoring'
+    else if (lowerTask.includes('implement') || lowerTask.includes('add')) type = 'feature'
+    else if (lowerTask.includes('design')) type = 'design'
+
+    // Complexity indicators
+    const complexityIndicators = {
+      high: ['architecture', 'redesign', 'migration', 'integration', 'authentication', 'database'],
+      medium: ['api', 'component', 'service', 'endpoint', 'feature'],
+      low: ['fix', 'update', 'modify', 'adjust', 'tweak'],
+    }
 
-      const freedMB = (totalFreed / 1024 / 1024).toFixed(2)
+    let level = 'medium'
+    let hours = 4
+
+    for (const [levelKey, indicators] of Object.entries(complexityIndicators)) {
+      if (indicators.some((indicator) => lowerTask.includes(indicator))) {
+        level = levelKey
+        break
+      }
+    }
 
-      const message = '🧹 Cleanup complete!\n' +
-        `• Files removed: ${filesRemoved}\n` +
-        `• Tasks archived: ${tasksArchived}\n` +
-        `• Space freed: ${freedMB} MB\n` +
-        '\n✨ Your project is clean and lean!'
+    // Estimate hours
+    if (level === 'high') hours = 8
+    else if (level === 'medium') hours = 4
+    else hours = 2
 
-      await this.logToMemory(projectPath, 'cleanup', {
-        filesRemoved,
-        tasksArchived,
-        spaceFeed: freedMB,
-      })
+    return { level, hours, type }
+  }
 
-      return {
-        success: true,
-        message: this.agent.formatResponse(message, 'success'),
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(`Cleanup failed: ${error.message}`, 'error'),
-      }
+  /**
+   * Auto-assign agent based on task
+   * @private
+   */
+  _autoAssignAgent(task) {
+    const lowerTask = task.toLowerCase()
+
+    if (
+      lowerTask.includes('ui') ||
+      lowerTask.includes('component') ||
+      lowerTask.includes('frontend')
+    ) {
+      return 'frontend-specialist'
+    }
+    if (
+      lowerTask.includes('api') ||
+      lowerTask.includes('backend') ||
+      lowerTask.includes('database')
+    ) {
+      return 'backend-specialist'
+    }
+    if (lowerTask.includes('test')) {
+      return 'qa-specialist'
+    }
+    if (lowerTask.includes('design') || lowerTask.includes('architecture')) {
+      return 'architect'
     }
+    if (lowerTask.includes('deploy') || lowerTask.includes('docker')) {
+      return 'devops-specialist'
+    }
+
+    return 'generalist'
   }
 
   /**
-   * Migrate all legacy projects to new structure
-   *
-   * @param {Object} [options={}] - Migration options
-   * @returns {Promise<Object>} Result object with summary
+   * /p:analyze - Analyze repository and generate summary
+   * AGENTIC EXECUTION
    */
-  async migrateAll(options = {}) {
+  async analyze(options = {}, projectPath = process.cwd()) {
     try {
       await this.initializeAgent()
 
-      const {
-        deepScan = false,
-        removeLegacy = false,
-        dryRun = false,
-      } = options
-
-      const onProgress = (update) => {
-        if (update.phase === 'scanning') {
-          console.log(`🔍 ${update.message}`)
-        } else if (update.phase === 'checking' || update.phase === 'migrating') {
-          console.log(`   ${update.message}`)
-        }
-      }
-
-      const summary = await migrator.migrateAll({
-        deepScan,
-        removeLegacy,
-        dryRun,
-        onProgress,
+      console.log('🔍 Analyzing repository...\n')
+
+      // Initialize analyzer for this project
+      const analyzer = require('./domain/analyzer')
+      analyzer.init(projectPath)
+
+      // Build context
+      const context = await contextBuilder.build(projectPath, options)
+
+      // Collect data using analyzer helpers (ZERO predetermined patterns)
+      const analysisData = {
+        // Package managers
+        packageJson: await analyzer.readPackageJson(),
+        cargoToml: await analyzer.readCargoToml(),
+        goMod: await analyzer.readGoMod(),
+        requirements: await analyzer.readRequirements(),
+
+        // Project structure
+        directories: await analyzer.listDirectories(),
+        fileCount: await analyzer.countFiles(),
+
+        // Git data
+        gitStats: await analyzer.getGitStats(),
+        gitLog: await analyzer.getGitLog(20),
+
+        // Common files
+        hasDockerfile: await analyzer.fileExists('Dockerfile'),
+        hasDockerCompose: await analyzer.fileExists('docker-compose.yml'),
+        hasReadme: await analyzer.fileExists('README.md'),
+        hasTsconfig: await analyzer.fileExists('tsconfig.json'),
+        hasViteConfig:
+          (await analyzer.fileExists('vite.config.ts')) ||
+          (await analyzer.fileExists('vite.config.js')),
+        hasNextConfig:
+          (await analyzer.fileExists('next.config.js')) ||
+          (await analyzer.fileExists('next.config.mjs')),
+      }
+
+      // Generate summary (Claude decides what's relevant based on data found)
+      const summary = this._generateAnalysisSummary(analysisData, projectPath)
+
+      // Save to analysis/repo-summary.md
+      const summaryPath =
+        context.paths.analysis ||
+        pathManager.getFilePath(
+          await configManager.getProjectId(projectPath),
+          'analysis',
+          'repo-summary.md'
+        )
+
+      await toolRegistry.get('Write')(summaryPath, summary)
+
+      // Log to memory
+      await this.logToMemory(projectPath, 'repository_analyzed', {
+        timestamp: dateHelper.getTimestamp(),
+        fileCount: analysisData.fileCount,
+        gitCommits: analysisData.gitStats.totalCommits,
       })
 
-      const report = migrator.generateMigrationSummary(summary)
+      console.log('✅ Analysis complete!\n')
+      console.log('📄 Full report: analysis/repo-summary.md\n')
+      console.log('Next steps:')
+      console.log('• /p:sync → Generate agents based on stack')
+      console.log('• /p:feature → Add a new feature')
 
       return {
-        success: summary.success,
-        message: report,
-        summary,
+        success: true,
+        summaryPath,
+        data: analysisData,
       }
     } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(`Global migration failed: ${error.message}`, 'error'),
-      }
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * First-time setup - Install commands to AI editors with ASCII art welcome
-   *
-   * @returns {Promise<Object>} Result object with success flag and message
+   * Generate analysis summary from collected data
+   * Claude decides what's relevant - NO predetermined patterns
+   * @private
    */
-  async start() {
-    try {
-      await this.initializeAgent()
-
-      // ASCII Art
-      const chalk = require('chalk')
-      console.log('')
-      console.log('')
-      console.log(chalk.bold.cyan('   ██████╗ ██████╗      ██╗ ██████╗████████╗'))
-      console.log(chalk.bold.cyan('   ██╔══██╗██╔══██╗     ██║██╔════╝╚══██╔══╝'))
-      console.log(chalk.bold.blue('   ██████╔╝██████╔╝     ██║██║        ██║'))
-      console.log(chalk.bold.blue('   ██╔═══╝ ██╔══██╗██   ██║██║        ██║'))
-      console.log(chalk.bold.magenta('   ██║     ██║  ██║╚█████╔╝╚██████╗   ██║'))
-      console.log(chalk.bold.magenta('   ╚═╝     ╚═╝  ╚═╝ ╚════╝  ╚═════╝   ╚═╝'))
-      console.log('')
-      console.log(chalk.dim.white('   Turn ideas into AI-ready roadmaps'))
-      console.log('')
-      console.log(chalk.yellow('   ⚡ Ship faster with zero friction'))
-      console.log(chalk.green('   📝 From idea to technical tasks in minutes'))
-      console.log(chalk.cyan('   🤖 Perfect context for AI agents'))
-      console.log('')
-
-      console.log(chalk.bold.magenta('📦 Setup - Install Commands to Claude\n'))
-
-      // Detect Claude
-      const commandInstaller = require('./command-installer')
-      const claudeDetected = await commandInstaller.detectClaude()
-
-      if (!claudeDetected) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            'Claude not detected.\n\nPlease install Claude Code or Claude Desktop first.\n\nVisit: https://claude.ai/download',
-            'error'
-          ),
+  _generateAnalysisSummary(data, projectPath) {
+    const lines = []
+
+    lines.push('# Repository Analysis\n')
+    lines.push(`Generated: ${new Date().toLocaleString()}\n`)
+
+    // Project name from path
+    const projectName = path.basename(projectPath)
+    lines.push(`## Project: ${projectName}\n`)
+
+    // Technologies detected (based on what files exist)
+    lines.push('## Stack Detected\n')
+
+    if (data.packageJson) {
+      lines.push('### JavaScript/TypeScript\n')
+      lines.push('- **Package Manager**: npm/yarn/pnpm')
+      if (data.packageJson.dependencies) {
+        const deps = Object.keys(data.packageJson.dependencies)
+        if (deps.length > 0) {
+          lines.push(
+            `- **Dependencies**: ${deps.slice(0, 10).join(', ')}${deps.length > 10 ? ` (+${deps.length - 10} more)` : ''}`
+          )
         }
       }
+      if (data.hasNextConfig) lines.push('- **Framework**: Next.js detected')
+      if (data.hasViteConfig) lines.push('- **Build Tool**: Vite detected')
+      if (data.hasTsconfig) lines.push('- **Language**: TypeScript')
+      lines.push('')
+    }
 
-      console.log(chalk.green('✓ Claude detected'))
-      console.log('')
-
-      // Install commands
-      console.log(chalk.cyan('Installing /p:* commands...'))
-      const installResult = await commandInstaller.installCommands()
+    if (data.cargoToml) {
+      lines.push('### Rust\n')
+      lines.push('- **Package Manager**: Cargo')
+      lines.push('- **Language**: Rust\n')
+    }
 
-      if (!installResult.success) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            `Installation failed: ${installResult.error || 'Unknown error'}`,
-            'error'
-          ),
-        }
-      }
+    if (data.goMod) {
+      lines.push('### Go\n')
+      lines.push('- **Package Manager**: Go modules')
+      lines.push('- **Language**: Go\n')
+    }
 
-      // Success message
-      const installedCount = installResult.installed?.length || 0
-      const errorCount = installResult.errors?.length || 0
+    if (data.requirements) {
+      lines.push('### Python\n')
+      lines.push('- **Package Manager**: pip')
+      lines.push('- **Language**: Python\n')
+    }
 
-      let message = `✅ Successfully installed ${installedCount} commands to Claude\n`
-      message += `   Location: ${installResult.path}\n`
+    // Project structure
+    lines.push('## Structure\n')
+    lines.push(`- **Total Files**: ${data.fileCount}`)
+    lines.push(
+      `- **Directories**: ${data.directories.slice(0, 15).join(', ')}${data.directories.length > 15 ? ` (+${data.directories.length - 15} more)` : ''}`
+    )
+
+    if (data.hasDockerfile) lines.push('- **Docker**: Detected')
+    if (data.hasDockerCompose) lines.push('- **Docker Compose**: Detected')
+    if (data.hasReadme) lines.push('- **Documentation**: README.md found')
+    lines.push('')
+
+    // Git stats
+    lines.push('## Git Statistics\n')
+    lines.push(`- **Total Commits**: ${data.gitStats.totalCommits}`)
+    lines.push(`- **Contributors**: ${data.gitStats.contributors}`)
+    lines.push(`- **Age**: ${data.gitStats.age}`)
+    lines.push('')
+
+    // Recent activity (if available)
+    if (data.gitLog) {
+      lines.push('## Recent Activity\n')
+      const logLines = data.gitLog.split('\n').slice(0, 5)
+      logLines.forEach((line) => {
+        if (line.trim()) {
+          const [hash, , time, msg] = line.split('|')
+          lines.push(`- \`${hash}\` ${msg} (${time})`)
+        }
+      })
+      lines.push('')
+    }
 
-      if (errorCount > 0) {
-        message += `\n⚠️  ${errorCount} command(s) had issues during installation`
-      }
+    // Recommendations
+    lines.push('## Recommendations\n')
+    lines.push('Based on detected stack, consider generating specialized agents using `/p:sync`.\n')
 
-      message += '\n\n✨ prjct is ready to use!'
-      message += '\n\nNext steps:'
-      message += '\n  cd your-project/'
-      message += '\n  prjct init'
-      message += '\n\nℹ️  Context7 MCP is automatically available in Claude'
+    lines.push('---\n')
+    lines.push(
+      '*This analysis was generated automatically. For updated information, run `/p:analyze` again.*\n'
+    )
 
-      return {
-        success: true,
-        message: this.agent.formatResponse(message, 'celebrate'),
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(`Setup failed: ${error.message}`, 'error'),
-      }
-    }
+    return lines.join('\n')
   }
 
   /**
-   * Setup/reconfigure commands in AI editors
-   *
-   * @param {Object} [options={}] - Installation options
-   * @returns {Promise<Object>} Result object with success flag and message
+   * /p:sync - Sync project state and generate dynamic agents
+   * AGENTIC EXECUTION
    */
-  async setup(options = {}) {
+  async sync(projectPath = process.cwd()) {
     try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
       await this.initializeAgent()
 
-      const { force = false } = options
+      console.log('🔄 Syncing project state...\n')
 
-      // Detect Claude
-      const commandInstaller = require('./command-installer')
-      const claudeDetected = await commandInstaller.detectClaude()
+      // Build context
+      const context = await contextBuilder.build(projectPath)
 
-      if (!claudeDetected) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            'Claude not detected. Please install Claude Code or Claude Desktop first.',
-            'error'
-          ),
-        }
-      }
+      // Step 1: Run analysis to get current state
+      console.log('📊 Running analysis...')
+      const analysisResult = await this.analyze({}, projectPath)
 
-      // Check current installation status
-      const status = await commandInstaller.checkInstallation()
+      if (!analysisResult.success) {
+        console.error('❌ Analysis failed')
+        return analysisResult
+      }
 
-      if (status.installed && !force) {
-        const chalk = require('chalk')
-        let report = chalk.green('✓ Commands already installed\n')
-        report += chalk.dim(`  Location: ${status.path}\n`)
-        report += chalk.dim(`  Commands: ${status.commands.length}\n`)
-        report += '\nUse --force to reinstall'
+      // Step 2: Read analysis/repo-summary.md
+      const summaryContent = await toolRegistry.get('Read')(context.paths.analysis)
 
-        return {
-          success: true,
-          message: this.agent.formatResponse(report, 'info'),
-        }
+      if (!summaryContent) {
+        console.error('❌ No analysis found. Run /p:analyze first.')
+        return { success: false, error: 'No analysis found' }
       }
 
-      // Install or reinstall commands
-      const installResult = force
-        ? await commandInstaller.updateCommands()
-        : await commandInstaller.installCommands()
+      console.log('✅ Analysis loaded\n')
 
-      if (!installResult.success) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            `Installation failed: ${installResult.error || 'Unknown error'}`,
-            'error'
-          ),
-        }
-      }
+      // Step 3: Generate dynamic agents based on stack detected
+      // Claude reads the summary and decides what specialists to create
+      console.log('🤖 Generating specialized agents...\n')
 
-      // Generate report
-      const installedCount = installResult.installed?.length || 0
-      const errorCount = installResult.errors?.length || 0
+      const projectId = await configManager.getProjectId(projectPath)
+      const AgentGenerator = require('./domain/agent-generator')
+      const generator = new AgentGenerator(projectId)
 
-      let report = `✅ Successfully ${force ? 'reinstalled' : 'installed'} ${installedCount} commands\n`
-      report += `   Location: ${installResult.path}\n`
+      const generatedAgents = await this._generateAgentsFromAnalysis(summaryContent, generator)
 
-      if (errorCount > 0) {
-        report += `\n⚠️  ${errorCount} command(s) had issues\n`
-        installResult.errors.forEach(err => {
-          report += `   - ${err.file}: ${err.error}\n`
-        })
-      }
+      // Step 4: Log to memory
+      await this.logToMemory(projectPath, 'agents_generated', {
+        timestamp: dateHelper.getTimestamp(),
+        agents: generatedAgents,
+        count: generatedAgents.length,
+      })
 
-      report += '\n📚 Context7 MCP is automatically available in Claude'
+      console.log('\n✅ Sync complete!\n')
+      console.log(`🤖 Agents Generated: ${generatedAgents.length}`)
+      generatedAgents.forEach((agent) => {
+        console.log(`   • ${agent}`)
+      })
+      console.log('\n📋 Based on: analysis/repo-summary.md')
+      console.log('💡 See templates/agents/AGENTS.md for reference\n')
+      console.log('Next steps:')
+      console.log('• /p:context → View project state')
+      console.log('• /p:feature → Add a feature')
 
       return {
         success: true,
-        message: this.agent.formatResponse(report, 'celebrate'),
+        agents: generatedAgents,
       }
     } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(`Installation failed: ${error.message}`, 'error'),
-      }
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 
   /**
-   * Analyze codebase and optionally sync with .prjct/ state
-   *
-   * @param {Object} [options={}] - Analysis options
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with analysis and sync results
+   * Generate agents dynamically from analysis summary
+   * Claude decides based on what technologies are detected
+   * @private
    */
-  async analyze(options = {}, projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+  async _generateAgentsFromAnalysis(summaryContent, generator) {
+    const agents = []
+
+    // Parse summary to identify technologies
+    // Simple detection based on sections (NOT predetermined patterns)
+
+    // Detect languages/frameworks from summary
+    const hasJavaScript =
+      summaryContent.includes('JavaScript') || summaryContent.includes('TypeScript')
+    const hasNextJS = summaryContent.includes('Next.js')
+    const hasVite = summaryContent.includes('Vite')
+    const hasReact = summaryContent.includes('react')
+    const hasRust = summaryContent.includes('Rust')
+    const hasGo = summaryContent.includes('Go')
+    const hasPython = summaryContent.includes('Python')
+    const hasDocker = summaryContent.includes('Docker')
+
+    // Generate agents based on detected stack
+    // Each agent is specific to THIS project's stack
+
+    if (hasJavaScript || hasNextJS || hasVite) {
+      await generator.generateDynamicAgent('frontend-specialist', {
+        role: 'Frontend Development Specialist',
+        expertise: `${hasNextJS ? 'Next.js' : hasVite ? 'Vite' : 'JavaScript/TypeScript'}, ${hasReact ? 'React' : 'Modern JavaScript frameworks'}`,
+        responsibilities:
+          'Handle UI components, state management, routing, and frontend architecture',
+        projectContext: {
+          detectedFramework: hasNextJS ? 'Next.js' : hasVite ? 'Vite + React' : 'JavaScript',
+        },
+      })
+      agents.push('frontend-specialist')
+    }
 
-      const {
-        sync = false,
-        reportOnly = false,
-        silent = false,
-      } = options
+    if (hasRust) {
+      await generator.generateDynamicAgent('rust-developer', {
+        role: 'Rust Development Specialist',
+        expertise: 'Rust, Cargo, performance optimization, memory safety',
+        responsibilities:
+          'Handle Rust codebase, performance-critical components, systems programming',
+        projectContext: { language: 'Rust' },
+      })
+      agents.push('rust-developer')
+    }
 
-      if (!silent) {
-        console.log('🔍 Analyzing codebase...')
-      }
+    if (hasGo) {
+      await generator.generateDynamicAgent('go-developer', {
+        role: 'Go Development Specialist',
+        expertise: 'Go, Go modules, concurrency, backend services',
+        responsibilities: 'Handle Go codebase, backend services, API development',
+        projectContext: { language: 'Go' },
+      })
+      agents.push('go-developer')
+    }
+
+    if (hasPython) {
+      await generator.generateDynamicAgent('python-developer', {
+        role: 'Python Development Specialist',
+        expertise: 'Python, pip, Django/Flask, data processing',
+        responsibilities: 'Handle Python codebase, backend logic, data processing',
+        projectContext: { language: 'Python' },
+      })
+      agents.push('python-developer')
+    }
 
-      const analysis = await analyzer.analyzeProject(projectPath)
+    if (hasDocker) {
+      await generator.generateDynamicAgent('devops-specialist', {
+        role: 'DevOps & Infrastructure Specialist',
+        expertise: 'Docker, Docker Compose, containerization, deployment',
+        responsibilities: 'Handle containerization, deployment, infrastructure setup',
+        projectContext: { hasDocker: true },
+      })
+      agents.push('devops-specialist')
+    }
 
-      const summary = {
-        commandsFound: analysis.commands.length,
-        featuresFound: analysis.features.length,
-        technologies: analysis.technologies.join(', '),
-        fileCount: analysis.structure.fileCount,
-        hasGit: analysis.gitHistory.hasGit,
-      }
+    // Always generate a QA specialist if we have code
+    await generator.generateDynamicAgent('qa-specialist', {
+      role: 'Quality Assurance Specialist',
+      expertise: 'Testing frameworks, test automation, quality metrics',
+      responsibilities: 'Handle testing strategy, test creation, quality assurance',
+      projectContext: { role: 'QA' },
+    })
+    agents.push('qa-specialist')
 
-      let syncResults = null
-      if (sync && !reportOnly) {
-        const globalProjectPath = await this.getGlobalProjectPath(projectPath)
-        syncResults = await analyzer.syncWithPrjctFiles(globalProjectPath)
-      }
+    return agents
+  }
+
+  /**
+   * First-time setup - Install commands to editors
+   */
+  async start() {
+    const commandInstaller = require('./infrastructure/command-installer')
 
-      let message = ''
+    console.log('🚀 Setting up prjct for Claude...\n')
 
-      if (silent) {
-        message = `Found ${summary.commandsFound} commands, ${summary.featuresFound} features`
-      } else if (reportOnly) {
-        message = this.formatAnalysisReport(summary, analysis)
-      } else if (sync) {
-        message = this.formatAnalysisWithSync(summary, syncResults)
-      } else {
-        message = this.formatAnalysisReport(summary, analysis)
-      }
+    // Check if Claude is installed
+    const status = await commandInstaller.checkInstallation()
 
+    if (!status.claudeDetected) {
       return {
-        success: true,
-        message: this.agent.formatResponse(message, 'info'),
-        analysis,
-        syncResults,
+        success: false,
+        message:
+          '❌ Claude not detected.\n\nPlease install Claude Code or Claude Desktop first:\n' +
+          '  - Claude Code: https://claude.com/code\n' +
+          '  - Claude Desktop: https://claude.com/desktop',
       }
-    } catch (error) {
-      await this.initializeAgent()
+    }
+
+    // Install commands
+    console.log('📦 Installing /p:* commands...')
+    const result = await commandInstaller.installCommands()
+
+    if (!result.success) {
       return {
         success: false,
-        message: this.agent.formatResponse(`Analysis failed: ${error.message}`, 'error'),
+        message: `❌ Installation failed: ${result.error}`,
       }
     }
+
+    console.log(`\n✅ Installed ${result.installed.length} commands to:\n   ${result.path}`)
+
+    if (result.errors.length > 0) {
+      console.log(`\n⚠️  ${result.errors.length} errors:`)
+      result.errors.forEach((e) => console.log(`   - ${e.file}: ${e.error}`))
+    }
+
+    console.log('\n🎉 Setup complete!')
+    console.log('\nNext steps:')
+    console.log('  1. Open Claude Code or Claude Desktop')
+    console.log('  2. Navigate to your project')
+    console.log('  3. Run: /p:init')
+
+    return {
+      success: true,
+      message: '',
+    }
   }
 
   /**
-   * Format analysis report for display
-   *
-   * @param {Object} summary - Analysis summary
-   * @param {Object} analysis - Full analysis results
-   * @returns {string} Formatted report
+   * Reconfigure editor installations
    */
-  formatAnalysisReport(summary, analysis) {
-    return `
-🔍 Codebase Analysis Complete
-
-📊 Project Overview:
-• Technologies: ${summary.technologies || 'Not detected'}
-• Total Files: ~${summary.fileCount}
-• Git Repository: ${summary.hasGit ? '✅ Yes' : '❌ No'}
+  async setup(options = {}) {
+    const commandInstaller = require('./infrastructure/command-installer')
 
-🛠️ Implemented Commands: ${summary.commandsFound}
-${analysis.commands.slice(0, 10).map(cmd => `  • /p:${cmd}`).join('\n')}
-${analysis.commands.length > 10 ? `  ... and ${analysis.commands.length - 10} more` : ''}
+    console.log('🔧 Reconfiguring prjct...\n')
 
-✨ Detected Features: ${summary.featuresFound}
-${analysis.features.slice(0, 5).map(f => `  • ${f}`).join('\n')}
-${analysis.features.length > 5 ? `  ... and ${analysis.features.length - 5} more` : ''}
+    if (options.force) {
+      console.log('🗑️  Removing existing installation...')
+      await commandInstaller.uninstallCommands()
+    }
 
-📝 Full report saved to: analysis/repo-summary.md
+    // Reinstall commands
+    console.log('📦 Installing /p:* commands...')
+    const result = await commandInstaller.updateCommands()
 
-💡 Use /p:analyze --sync to sync with .prjct/ files
-`
-  }
+    if (!result.success) {
+      return {
+        success: false,
+        message: `❌ Setup failed: ${result.error}`,
+      }
+    }
 
-  /**
-   * Format analysis with sync results
-   *
-   * @param {Object} summary - Analysis summary
-   * @param {Object} syncResults - Sync results
-   * @returns {string} Formatted report with sync info
-   */
-  formatAnalysisWithSync(summary, syncResults) {
-    return `
-🔍 Analysis & Sync Complete
+    console.log(`\n✅ Installed ${result.installed.length} commands`)
 
-📊 Detected:
-✅ ${summary.commandsFound} implemented commands
-✅ ${summary.featuresFound} completed features
+    if (result.errors.length > 0) {
+      console.log(`\n⚠️  ${result.errors.length} errors:`)
+      result.errors.forEach((e) => console.log(`   - ${e.file}: ${e.error}`))
+    }
 
-📝 Synchronized:
-${syncResults.nextMdUpdated ? `✅ Updated next.md (${syncResults.tasksMarkedComplete} tasks marked complete)` : '• next.md (no changes)'}
-${syncResults.shippedMdUpdated ? `✅ Updated shipped.md (${syncResults.featuresAdded} features added)` : '• shipped.md (no changes)'}
-✅ Created analysis/repo-summary.md
+    console.log('\n🎉 Setup complete!')
 
-💡 Next: Use /p:next to see remaining tasks
-`
+    return {
+      success: true,
+      message: '',
+    }
   }
 
   /**
-   * Sync project state and update AI agents
-   * Re-analyzes the project and regenerates workflow agents in global project directory
-   *
-   * @param {string} [projectPath=process.cwd()] - Project directory path
-   * @returns {Promise<Object>} Result with success status and message
+   * Migrate all legacy projects
    */
-  async sync(projectPath = process.cwd()) {
-    try {
-      await this.initializeAgent()
+  async migrateAll(options = {}) {
+    const fs = require('fs').promises
+    const path = require('path')
 
-      // Get project ID from config
-      const config = await configManager.readConfig(projectPath)
-      if (!config || !config.projectId) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            'Project not initialized. Run /p:init first.',
-            'error',
-          ),
-        }
+    console.log('🔄 Scanning for legacy prjct projects...\n')
+
+    const homeDir = require('os').homedir()
+    const globalRoot = path.join(homeDir, '.prjct-cli', 'projects')
+
+    // Get all project IDs
+    let projectIds = []
+    try {
+      const dirs = await fs.readdir(globalRoot)
+      projectIds = dirs.filter((d) => !d.startsWith('.'))
+    } catch (error) {
+      return {
+        success: false,
+        message: '❌ No prjct projects found',
       }
+    }
 
-      console.log('🔄 Syncing project state...\n')
+    console.log(`📁 Found ${projectIds.length} projects in global storage\n`)
 
-      // Step 1: Re-run project analysis
-      const analysisResult = await this.analyze({ silent: true }, projectPath)
+    const migrated = []
+    const failed = []
+    const skipped = []
 
-      if (!analysisResult.success) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(`Sync failed: ${analysisResult.message}`, 'error'),
-        }
-      }
+    for (const projectId of projectIds) {
+      const globalProjectPath = path.join(globalRoot, projectId)
 
-      const { analysis } = analysisResult
-      const summary = {
-        commandsFound: analysis.commands.length,
-        featuresFound: analysis.features.length,
+      // Read global config to get project path
+      const globalConfig = await configManager.readGlobalConfig(projectId)
+      if (!globalConfig || !globalConfig.projectPath) {
+        skipped.push({ projectId, reason: 'No project path in config' })
+        continue
       }
 
-      console.log('📊 Analysis Complete')
-      console.log(`   ✅ ${summary.commandsFound} commands detected`)
-      console.log(`   ✅ ${summary.featuresFound} features implemented\n`)
+      const projectPath = globalConfig.projectPath
 
-      // Step 2: Generate/update all agents in project directory
-      const AgentGenerator = agentGenerator
-      const generator = new AgentGenerator(config.projectId)
+      // Check if needs migration
+      if (!(await migrator.needsMigration(projectPath))) {
+        skipped.push({ projectId, reason: 'Already migrated' })
+        continue
+      }
 
-      const generatedAgents = await generator.generateAll(analysis)
+      console.log(`🔄 Migrating: ${projectPath}`)
 
-      // Step 3: Log sync action to memory
-      await this.logAction(projectPath, 'sync', {
-        commandsDetected: summary.commandsFound,
-        featuresDetected: summary.featuresFound,
-        agentsGenerated: generatedAgents.length,
-        agents: generatedAgents,
-      })
+      try {
+        const result = await migrator.migrate(projectPath, options)
 
-      const agentsPath = path.join(
-        pathManager.getProjectRoot(config.projectId),
-        'agents',
-      )
+        if (result.success) {
+          migrated.push({ projectId, path: projectPath })
+          console.log(`   ✅ ${result.message}`)
+        } else {
+          failed.push({ projectId, path: projectPath, error: result.message })
+          console.log(`   ❌ ${result.message}`)
+        }
+      } catch (error) {
+        failed.push({ projectId, path: projectPath, error: error.message })
+        console.log(`   ❌ ${error.message}`)
+      }
 
-      const message = `
-🔄 Sync Complete
+      console.log('')
+    }
 
-📊 Project State:
-   ✅ ${summary.commandsFound} commands detected
-   ✅ ${summary.featuresFound} features implemented
+    // Summary
+    console.log('\n📊 Migration Summary:')
+    console.log(`   ✅ Migrated: ${migrated.length}`)
+    console.log(`   ⏭️  Skipped: ${skipped.length}`)
+    console.log(`   ❌ Failed: ${failed.length}`)
 
-🤖 Workflow Agents:
-   ✨ Generated ${generatedAgents.length} agents in ${agentsPath}
-   ${generatedAgents.map(a => `✅ ${a.toUpperCase()}`).join('\n   ')}
+    if (failed.length > 0) {
+      console.log('\n❌ Failed migrations:')
+      failed.forEach((f) => console.log(`   - ${f.path}: ${f.error}`))
+    }
 
-💡 Agents ready for workflow task assignment!
-`
+    return {
+      success: failed.length === 0,
+      message: '',
+    }
+  }
 
-      return {
-        success: true,
-        message: this.agent.formatResponse(message, 'success'),
-        generatedAgents,
-      }
-    } catch (error) {
-      await this.initializeAgent()
+  /**
+   * Execute architect plan and generate code
+   */
+  async architect(action = 'execute', projectPath = process.cwd()) {
+    if (action !== 'execute') {
       return {
         success: false,
-        message: this.agent.formatResponse(`Sync failed: ${error.message}`, 'error'),
+        message: '❌ Invalid action. Use: /p:architect execute',
       }
     }
-  }
 
-  /**
-   * Show workflow status
-   *
-   * @param {string} [projectPath=process.cwd()] - Project path
-   * @returns {Promise<Object>} Result object with success flag and message
-   */
-  async workflow(projectPath = process.cwd()) {
     try {
-      await this.initializeAgent()
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-      // Auto-init if not configured
-      const initCheck = await this.ensureProjectInit(projectPath)
-      if (!initCheck.success) {
-        return initCheck
-      }
+      console.log('🏗️  Architect Mode - Code Generation\n')
 
-      const config = await configManager.readConfig(projectPath)
-      const globalProjectPath = pathManager.getProjectRoot(config.projectId)
+      const globalPath = await this.getGlobalProjectPath(projectPath)
+      const architectSession = require('./domain/architect-session')
 
-      const workflow = await workflowEngine.load(globalProjectPath)
+      // Check if there's a completed plan
+      const planPath = path.join(globalPath, 'planning', 'architect-session.md')
 
-      if (!workflow || !workflow.active) {
+      let planContent
+      try {
+        planContent = await fileHelper.readFile(planPath)
+      } catch (error) {
         return {
-          success: true,
-          message: this.agent.formatResponse(
-            `No active workflow.\n\nStart one with ${this.agentInfo.config.commandPrefix}idea "implement [feature]"`,
-            'info',
-          ),
+          success: false,
+          message:
+            '❌ No architect plan found.\n\n' +
+            'Create a plan first:\n' +
+            '  1. Run /p:init in an empty directory\n' +
+            '  2. Answer the discovery questions\n' +
+            '  3. Plan will be auto-generated\n' +
+            '  4. Then run /p:architect execute',
         }
       }
 
-      const currentStep = workflow.steps[workflow.current]
-      const completedSteps = workflow.steps.slice(0, workflow.current)
-      const remainingSteps = workflow.steps.slice(workflow.current + 1)
-
-      let message = `🔄 Workflow: ${workflow.type}\n`
-      message += `📋 Task: ${workflow.task}\n\n`
-
-      if (completedSteps.length > 0) {
-        message += `✅ Completed:\n`
-        completedSteps.forEach((step) => {
-          message += `   - ${step.name}: ${step.action} (${step.agent})\n`
-        })
-        message += '\n'
-      }
-
-      message += `🎯 Current Step:\n`
-      message += `   - ${currentStep.name}: ${currentStep.action} (${currentStep.agent})\n`
-      if (currentStep.required) {
-        message += `   Required: Yes\n`
+      if (!planContent || planContent.trim() === '') {
+        return {
+          success: false,
+          message: '❌ Architect plan is empty',
+        }
       }
-      message += '\n'
 
-      if (remainingSteps.length > 0) {
-        message += `⏳ Remaining:\n`
-        remainingSteps.forEach((step) => {
-          message += `   - ${step.name}: ${step.action} (${step.agent})\n`
-        })
-        message += '\n'
-      }
+      console.log('📋 Reading architect plan...\n')
 
-      message += `Progress: ${workflow.current + 1}/${workflow.steps.length} steps`
+      // Extract key information from plan
+      const ideaMatch = planContent.match(/## Project Idea\n(.+)/s)
+      const stackMatch = planContent.match(/\*\*Stack:\*\*\n([\s\S]+?)\n\n/)
+      const stepsMatch = planContent.match(/\*\*Implementation Steps:\*\*\n([\s\S]+?)\n\n/)
 
-      return {
-        success: true,
-        message: this.agent.formatResponse(message, 'info'),
-        workflow,
-      }
-    } catch (error) {
-      await this.initializeAgent()
-      return {
-        success: false,
-        message: this.agent.formatResponse(`Workflow status failed: ${error.message}`, 'error'),
-      }
-    }
-  }
+      const idea = ideaMatch ? ideaMatch[1].split('\n')[0].trim() : 'Unknown project'
+      const stack = stackMatch ? stackMatch[1] : 'Not specified'
+      const steps = stepsMatch ? stepsMatch[1] : 'Not specified'
 
-  /**
-   * Detect if project has existing code (for auto-analyze during init)
-   *
-   * @param {string} projectPath - Project path
-   * @returns {Promise<boolean>} True if project has significant existing code
-   */
-  async detectExistingCode(projectPath) {
-    try {
-      const packagePath = path.join(projectPath, 'package.json')
-      try {
-        const content = await fs.readFile(packagePath, 'utf-8')
-        const pkg = JSON.parse(content)
+      console.log(`📝 Project: ${idea}`)
+      console.log(`\n🔧 Stack:\n${stack}`)
+      console.log(`\n📋 Implementation Steps:\n${steps}`)
 
-        if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
-          return true
-        }
-      } catch {
-      }
+      console.log('\n' + '='.repeat(60))
+      console.log('🤖 READY TO GENERATE CODE')
+      console.log('='.repeat(60))
 
-      try {
-        const { stdout } = await exec('git rev-list --count HEAD', { cwd: projectPath })
-        const commitCount = parseInt(stdout.trim())
-        if (commitCount > 0) {
-          return true
-        }
-      } catch {
-      }
+      console.log(
+        '\nThe architect plan is ready. Claude will now:\n' +
+          '  1. Read the architectural plan\n' +
+          '  2. Use Context7 for official documentation\n' +
+          '  3. Generate project structure\n' +
+          '  4. Create starter files with boilerplate\n'
+      )
 
-      const entries = await fs.readdir(projectPath)
-      const codeExtensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.rb', '.java']
+      console.log('\n💡 This command shows the plan.')
+      console.log('   For code generation, Claude Code will read this plan')
+      console.log('   and generate the structure automatically.\n')
 
-      let codeFileCount = 0
-      for (const entry of entries) {
-        if (entry.startsWith('.') || entry === 'node_modules') {
-          continue
-        }
+      await this.logToMemory(projectPath, 'architect_executed', {
+        timestamp: dateHelper.getTimestamp(),
+        idea,
+      })
 
-        const ext = path.extname(entry)
-        if (codeExtensions.includes(ext)) {
-          codeFileCount++
-        }
+      return {
+        success: true,
+        plan: planContent,
+        idea,
       }
-
-      return codeFileCount >= 5
     } catch (error) {
-      return false
+      console.error('❌ Error:', error.message)
+      return { success: false, error: error.message }
     }
   }
 }
 
-module.exports = new PrjctCommands()
+module.exports = PrjctCommands