@nclamvn/vibecode-cli 1.8.1 → 2.1.0

package/SESSION_NOTES.md

@@ -1,5 +1,5 @@
 # VIBECODE CLI - SESSION NOTES
-> Cập nhật: 2025-12-22
+> Cập nhật: 2025-12-22 (Latest)
 
 ---
 
@@ -20,8 +20,9 @@
    - CLI: https://github.com/nclamvn/vibecode-cli
    - Docs: https://github.com/nclamvn/vibecode-docs
 
-4. **NPM Package** - Deprecated (beta warning)
+4. **NPM Package**
    - Package: @nclamvn/vibecode-cli
+   - Version: **1.8.1** (latest)
    - Status: Deprecated với message cảnh báo beta
 
 5. **UI Fixes**
@@ -30,6 +31,12 @@
    - Theme toggle icon thu nhỏ 60%
    - Default: Light mode
 
+6. **Bug Fix: Version Hardcoded** ✅ FIXED
+   - File: `src/config/constants.js`
+   - Before: `export const VERSION = '1.0.1'` (hardcoded)
+   - After: `export const VERSION = pkg.version` (dynamic)
+   - Published: v1.8.1
+
 ---
 
 ## 🚧 ĐANG LÀM
@@ -37,7 +44,10 @@
 ### Deploy Render
 - Repo: nclamvn/vibecode-docs
 - File: render.yaml đã có
-- **BƯỚC TIẾP THEO**: Điền `build` vào Publish Directory rồi click Deploy
+- URL Dashboard: https://dashboard.render.com/static/new
+- **BƯỚC TIẾP THEO**:
+  1. Điền `build` vào Publish Directory
+  2. Click "Deploy Static Site"
 
 ---
 
@@ -46,8 +56,9 @@
 ```
 /Users/mac/vibecode-cli/
 ├── src/                    # CLI source (26 commands)
+│   └── config/constants.js # VERSION đọc từ package.json
 ├── bin/vibecode.js         # Entry point
-├── package.json            # v1.8.0
+├── package.json            # v1.8.1
 ├── docs-site/              # Docusaurus site (separate git repo)
 │   ├── src/pages/index.tsx # Landing page
 │   ├── docs/               # English docs
@@ -61,13 +72,16 @@
 ## 🔧 COMMANDS THƯỜNG DÙNG
 
 ```bash
-# Dev server
+# Dev server docs
 cd /Users/mac/vibecode-cli/docs-site
 npm start
 
-# Build
+# Build docs
 npm run build
 
+# Test CLI version
+node bin/vibecode.js --version
+
 # Push docs
 cd /Users/mac/vibecode-cli/docs-site
 git add . && git commit -m "message" && git push
@@ -76,6 +90,10 @@ git add . && git commit -m "message" && git push
 cd /Users/mac/vibecode-cli
 git add . && git commit -m "message" && git push
 
+# Publish npm (khi cần)
+npm version patch
+npm publish
+
 # Bỏ deprecate npm khi sẵn sàng
 npm deprecate @nclamvn/vibecode-cli ""
 ```
@@ -86,6 +104,7 @@ npm deprecate @nclamvn/vibecode-cli ""
 
 | Metric | Value |
 |--------|-------|
+| CLI Version | 1.8.1 |
 | CLI Commands | 26 |
 | Lines of Code | 18,612 |
 | JS Files | 167 |
@@ -95,7 +114,7 @@ npm deprecate @nclamvn/vibecode-cli ""
 
 ## 🎯 VIỆC CẦN LÀM TIẾP
 
-1. [ ] Hoàn thành deploy Render
+1. [ ] Hoàn thành deploy Render (điền `build` → Deploy)
 2. [ ] Test site trên production URL
 3. [ ] Phase L: Unit Tests & TypeScript (optional)
 4. [ ] Khi sẵn sàng: Bỏ deprecate npm package
@@ -104,11 +123,23 @@ npm deprecate @nclamvn/vibecode-cli ""
 
 ## 🔗 LINKS
 
-- Landing EN: http://localhost:3000/
-- Landing VI: http://localhost:3000/vi/
-- GitHub CLI: https://github.com/nclamvn/vibecode-cli
-- GitHub Docs: https://github.com/nclamvn/vibecode-docs
-- NPM: https://www.npmjs.com/package/@nclamvn/vibecode-cli
+| Resource | URL |
+|----------|-----|
+| Landing Local EN | http://localhost:3000/ |
+| Landing Local VI | http://localhost:3000/vi/ |
+| GitHub CLI | https://github.com/nclamvn/vibecode-cli |
+| GitHub Docs | https://github.com/nclamvn/vibecode-docs |
+| NPM Package | https://www.npmjs.com/package/@nclamvn/vibecode-cli |
+| Render Dashboard | https://dashboard.render.com |
+
+---
+
+## 📝 LỊCH SỬ SESSION
+
+| Thời gian | Việc đã làm |
+|-----------|-------------|
+| Session 1 | Landing page, i18n, UI fixes |
+| Session 2 | GitHub push, npm deprecate, version bug fix |
 
 ---
 
@@ -116,4 +147,8 @@ npm deprecate @nclamvn/vibecode-cli ""
 
 Chỉ cần nói: **"tiếp tục"** hoặc **"continue"**
 
+Hoặc cụ thể hơn:
+- "tiếp tục deploy render"
+- "đọc SESSION_NOTES.md và cho tôi biết trạng thái"
+
 Claude sẽ đọc file này và biết cần làm gì tiếp.

package/bin/vibecode.js

@@ -146,12 +146,14 @@ program
 // ─────────────────────────────────────────────────────────────────────────────
 
 program
-  .command('agent <description>')
+  .command('agent [description...]')
   .description('Agent mode: autonomous multi-module builder with self-healing')
   .option('-n, --new', 'Create new project directory')
+  .option('-r, --resume', 'Resume from last stopped module')
+  .option('--from <n>', 'Resume from specific module number', parseInt)
+  .option('-s, --status', 'Show current agent progress')
   .option('-v, --verbose', 'Show detailed progress')
   .option('--analyze', 'Analyze project structure without building')
-  .option('--status', 'Show agent status and memory stats')
   .option('--report', 'Export memory report to markdown')
   .option('--clear', 'Clear agent memory')
   .option('--force', 'Force operation (for --clear)')
@@ -160,7 +162,11 @@ program
   .option('--skip-tests', 'Skip tests after each module')
   .option('--continue', 'Continue on module failure')
   .option('--stdout', 'Output report to stdout (for --report)')
-  .action(agentCommand);
+  .action((description, options) => {
+    // Join variadic description
+    const desc = Array.isArray(description) ? description.join(' ') : description;
+    agentCommand(desc, options);
+  });
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Phase G Commands - Debug Mode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nclamvn/vibecode-cli",
-  "version": "1.8.1",
+  "version": "2.1.0",
   "description": "Build software with discipline - AI coding with guardrails",
   "main": "src/index.js",
   "type": "module",

package/src/agent/index.js

@@ -11,7 +11,13 @@ import fs from 'fs-extra';
 import { DecompositionEngine, createDecompositionEngine } from './decomposition.js';
 import { MemoryEngine, createMemoryEngine } from './memory.js';
 import { SelfHealingEngine, createSelfHealingEngine } from './self-healing.js';
-import { Orchestrator, createOrchestrator, ORCHESTRATOR_STATES } from './orchestrator.js';
+import {
+  Orchestrator,
+  createOrchestrator,
+  ORCHESTRATOR_STATES,
+  loadProgress,
+  loadDecomposition
+} from './orchestrator.js';
 
 /**
  * Vibecode Agent Class
@@ -213,6 +219,64 @@ export class VibecodeAgent {
     console.log();
   }
 
+  /**
+   * Resume a previously interrupted build
+   */
+  async resume(options = {}) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    // Load progress to show header
+    const progress = await loadProgress(this.projectPath);
+    if (!progress) {
+      console.log(chalk.yellow('\n📭 No previous session found.\n'));
+      console.log(chalk.gray('   Start new build: vibecode agent "description" --new\n'));
+      return null;
+    }
+
+    this.showResumeHeader(progress, options);
+
+    try {
+      this.buildResult = await this.orchestrator.resumeBuild(options);
+      this.showResults(this.buildResult);
+      return this.buildResult;
+    } catch (error) {
+      console.error(chalk.red(`\nAgent resume failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * Show resume header
+   */
+  showResumeHeader(progress, options) {
+    const fromModule = options.fromModule !== undefined
+      ? options.fromModule + 1
+      : progress.currentModule + 1;
+    const totalModules = progress.totalModules;
+    const completed = progress.completedModules?.length || progress.currentModule || 0;
+
+    console.log();
+    console.log(chalk.cyan('╭' + '─'.repeat(68) + '╮'));
+    console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + chalk.bold.white('   🔄 RESUMING AGENT') + ' '.repeat(48) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+
+    const projectLine = `   Project: ${progress.projectName}`;
+    console.log(chalk.cyan('│') + chalk.white(projectLine) + ' '.repeat(Math.max(0, 66 - projectLine.length)) + chalk.cyan('│'));
+
+    const progressLine = `   Progress: ${completed}/${totalModules} modules completed`;
+    console.log(chalk.cyan('│') + chalk.white(progressLine) + ' '.repeat(Math.max(0, 66 - progressLine.length)) + chalk.cyan('│'));
+
+    const resumeLine = `   Resuming from module ${fromModule}`;
+    console.log(chalk.cyan('│') + chalk.yellow(resumeLine) + ' '.repeat(Math.max(0, 66 - resumeLine.length)) + chalk.cyan('│'));
+
+    console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+    console.log(chalk.cyan('╰' + '─'.repeat(68) + '╯'));
+    console.log();
+  }
+
   /**
    * Quick build helper
    */
@@ -321,5 +385,7 @@ export {
   createSelfHealingEngine,
   Orchestrator,
   createOrchestrator,
-  ORCHESTRATOR_STATES
+  ORCHESTRATOR_STATES,
+  loadProgress,
+  loadDecomposition
 };

package/src/agent/orchestrator.js

@@ -15,6 +15,67 @@ import { ProgressDashboard } from '../ui/dashboard.js';
 import { translateError, showError, inlineError } from '../ui/error-translator.js';
 import { BackupManager } from '../core/backup.js';
 
+/**
+ * Progress file for resume functionality
+ */
+const PROGRESS_FILE = '.vibecode/agent-progress.json';
+const DECOMPOSITION_FILE = '.vibecode/agent-decomposition.json';
+
+/**
+ * Save agent progress to file
+ */
+export async function saveProgress(projectPath, progress) {
+  const progressPath = path.join(projectPath, PROGRESS_FILE);
+  await fs.ensureDir(path.dirname(progressPath));
+  await fs.writeFile(progressPath, JSON.stringify(progress, null, 2));
+}
+
+/**
+ * Load agent progress from file
+ */
+export async function loadProgress(projectPath) {
+  try {
+    const progressPath = path.join(projectPath, PROGRESS_FILE);
+    const content = await fs.readFile(progressPath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Clear agent progress file
+ */
+export async function clearProgress(projectPath) {
+  try {
+    await fs.unlink(path.join(projectPath, PROGRESS_FILE));
+  } catch {
+    // Ignore if file doesn't exist
+  }
+}
+
+/**
+ * Save decomposition for resume
+ */
+export async function saveDecomposition(projectPath, decomposition) {
+  const decompositionPath = path.join(projectPath, DECOMPOSITION_FILE);
+  await fs.ensureDir(path.dirname(decompositionPath));
+  await fs.writeFile(decompositionPath, JSON.stringify(decomposition, null, 2));
+}
+
+/**
+ * Load decomposition from file
+ */
+export async function loadDecomposition(projectPath) {
+  try {
+    const decompositionPath = path.join(projectPath, DECOMPOSITION_FILE);
+    const content = await fs.readFile(decompositionPath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Orchestrator states
  */
@@ -186,6 +247,13 @@ export class Orchestrator {
 
       const decomposition = await this.decompositionEngine.decompose(description, options);
 
+      // Save decomposition for resume functionality
+      await saveDecomposition(this.projectPath, {
+        ...decomposition,
+        description,
+        startedAt: new Date().toISOString()
+      });
+
       // Store in memory
       if (this.memoryEngine) {
         await this.memoryEngine.setProjectContext({
@@ -201,11 +269,13 @@ export class Orchestrator {
       // Step 2: Build modules in order
       this.setState(ORCHESTRATOR_STATES.BUILDING);
 
-      const results = await this.buildModules(decomposition);
+      const results = await this.buildModules(decomposition, options);
 
       // Step 3: Final summary
       if (results.success) {
         this.setState(ORCHESTRATOR_STATES.COMPLETED);
+        // Clear progress on success
+        await clearProgress(this.projectPath);
       } else {
         this.setState(ORCHESTRATOR_STATES.FAILED);
       }
@@ -219,41 +289,149 @@ export class Orchestrator {
     }
   }
 
+  /**
+   * Resume build from previous progress
+   */
+  async resumeBuild(options = {}) {
+    this.buildState.startTime = Date.now();
+
+    // Load progress
+    const progress = await loadProgress(this.projectPath);
+    if (!progress) {
+      throw new Error('No previous progress found. Start a new build with: vibecode agent "description"');
+    }
+
+    // Load decomposition
+    const savedDecomposition = await loadDecomposition(this.projectPath);
+    if (!savedDecomposition) {
+      throw new Error('No decomposition found. Start a new build with: vibecode agent "description"');
+    }
+
+    try {
+      // Restore decomposition engine state
+      await this.decompositionEngine.decompose(savedDecomposition.description, options);
+
+      // Update module statuses from progress
+      for (const mod of progress.modules) {
+        if (mod.status === 'done') {
+          this.decompositionEngine.updateModuleStatus(mod.id, 'completed', {
+            files: mod.files || []
+          });
+          this.buildState.completedModules.push(mod.id);
+        }
+      }
+
+      // Store in memory
+      if (this.memoryEngine) {
+        await this.memoryEngine.setProjectContext({
+          description: progress.description,
+          type: savedDecomposition.projectType,
+          complexity: savedDecomposition.estimatedComplexity,
+          totalModules: savedDecomposition.totalModules
+        });
+      }
+
+      await this.log(`Resuming from module ${progress.currentModule + 1}`);
+
+      // Determine start index
+      const startIndex = options.fromModule !== undefined
+        ? options.fromModule
+        : progress.currentModule;
+
+      // Build remaining modules
+      this.setState(ORCHESTRATOR_STATES.BUILDING);
+      const results = await this.buildModules(savedDecomposition, {
+        ...options,
+        startIndex
+      });
+
+      // Final summary
+      if (results.success) {
+        this.setState(ORCHESTRATOR_STATES.COMPLETED);
+        await clearProgress(this.projectPath);
+      } else {
+        this.setState(ORCHESTRATOR_STATES.FAILED);
+      }
+
+      return this.generateBuildReport(savedDecomposition, results);
+
+    } catch (error) {
+      this.setState(ORCHESTRATOR_STATES.FAILED);
+      await this.log(`Resume failed: ${error.message}`, 'error');
+      throw error;
+    }
+  }
+
   /**
    * Build all modules in dependency order
    */
-  async buildModules(decomposition) {
+  async buildModules(decomposition, options = {}) {
     const results = {
       success: true,
       modules: {},
       totalTime: 0
     };
 
+    // Determine start index for resume
+    const startIndex = options.startIndex || 0;
+    const buildOrder = decomposition.buildOrder;
+
     // Create and start dashboard if enabled
     if (this.config.useDashboard) {
       this.dashboard = new ProgressDashboard({
-        title: 'VIBECODE AGENT',
+        title: startIndex > 0 ? 'VIBECODE AGENT (RESUME)' : 'VIBECODE AGENT',
         projectName: path.basename(this.projectPath),
         mode: `Agent (${decomposition.totalModules} modules)`
       });
 
-      // Set modules for dashboard
-      this.dashboard.setModules(decomposition.buildOrder.map(id => {
+      // Set modules for dashboard with correct status for resumed builds
+      this.dashboard.setModules(buildOrder.map((id, idx) => {
         const mod = this.decompositionEngine.getModule(id);
-        return { name: mod?.name || id };
+        return {
+          name: mod?.name || id,
+          status: idx < startIndex ? 'completed' : 'pending'
+        };
       }));
 
       this.dashboard.start();
+
+      // Show resume message
+      if (startIndex > 0) {
+        this.dashboard.addLog(`Resuming from module ${startIndex + 1}: ${buildOrder[startIndex]}`);
+      }
     }
 
     try {
-      for (const moduleId of decomposition.buildOrder) {
+      for (let i = startIndex; i < buildOrder.length; i++) {
+        const moduleId = buildOrder[i];
+
         // Check if we should stop
         if (this.state === ORCHESTRATOR_STATES.PAUSED) {
           await this.log('Build paused');
           break;
         }
 
+        // Save progress before building this module
+        await saveProgress(this.projectPath, {
+          projectName: path.basename(this.projectPath),
+          description: decomposition.description,
+          totalModules: decomposition.totalModules,
+          completedModules: this.buildState.completedModules,
+          currentModule: i,
+          modules: buildOrder.map((id, idx) => {
+            const mod = this.decompositionEngine.getModule(id);
+            return {
+              id,
+              name: mod?.name || id,
+              status: idx < i ? 'done' : idx === i ? 'building' : 'pending',
+              files: mod?.files || []
+            };
+          }),
+          startedAt: decomposition.startedAt || new Date().toISOString(),
+          lastUpdated: new Date().toISOString(),
+          error: null
+        });
+
         // Check if module can be built (dependencies satisfied)
         if (!this.decompositionEngine.canBuildModule(moduleId)) {
           const depStatus = decomposition.dependencyGraph[moduleId];
@@ -295,11 +473,37 @@ export class Orchestrator {
           }
         }
 
+        // Save progress after module completion
+        await saveProgress(this.projectPath, {
+          projectName: path.basename(this.projectPath),
+          description: decomposition.description,
+          totalModules: decomposition.totalModules,
+          completedModules: this.buildState.completedModules,
+          currentModule: moduleResult.success ? i + 1 : i,
+          failedModule: moduleResult.success ? null : i,
+          modules: buildOrder.map((id, idx) => {
+            const mod = this.decompositionEngine.getModule(id);
+            const status = idx < i ? 'done'
+              : idx === i ? (moduleResult.success ? 'done' : 'failed')
+              : 'pending';
+            return {
+              id,
+              name: mod?.name || id,
+              status,
+              files: mod?.files || []
+            };
+          }),
+          startedAt: decomposition.startedAt || new Date().toISOString(),
+          lastUpdated: new Date().toISOString(),
+          error: moduleResult.success ? null : moduleResult.error
+        });
+
         if (!moduleResult.success) {
           results.success = false;
 
           if (!this.config.continueOnFailure) {
             await this.log(`Stopping build due to module failure: ${moduleId}`, 'error');
+            console.log(chalk.yellow(`\n💡 Resume later with: vibecode agent --resume\n`));
             break;
           }
         }

package/src/commands/agent.js

@@ -7,7 +7,7 @@ import chalk from 'chalk';
 import path from 'path';
 import fs from 'fs-extra';
 
-import { createAgent } from '../agent/index.js';
+import { createAgent, loadProgress } from '../agent/index.js';
 import { printError, printSuccess } from '../ui/output.js';
 import { isClaudeCodeAvailable } from '../providers/index.js';
 
@@ -16,6 +16,14 @@ import { isClaudeCodeAvailable } from '../providers/index.js';
  * vibecode agent "description" [options]
  */
 export async function agentCommand(description, options = {}) {
+  // Handle description as array (from commander variadic)
+  const desc = Array.isArray(description) ? description.join(' ') : description;
+
+  // Handle sub-commands that don't need Claude Code check first
+  if (options.status) {
+    return showAgentStatus(options);
+  }
+
   // Check for Claude Code
   const claudeAvailable = await isClaudeCodeAvailable();
   if (!claudeAvailable) {
@@ -24,8 +32,24 @@ export async function agentCommand(description, options = {}) {
     process.exit(1);
   }
 
-  // Validate description
-  if (!description || description.trim().length < 5) {
+  // Handle resume
+  if (options.resume) {
+    return resumeCommand(options);
+  }
+
+  // Validate description for non-resume commands
+  if (!desc || desc.trim().length < 5) {
+    // Check if there's a session to resume
+    const progress = await loadProgress(process.cwd());
+    if (progress) {
+      console.log(chalk.cyan('\n📦 Found existing session:'));
+      console.log(chalk.white(`   Project: ${progress.projectName}`));
+      console.log(chalk.white(`   Progress: ${progress.completedModules?.length || progress.currentModule}/${progress.totalModules} modules\n`));
+      console.log(chalk.gray('   Resume: vibecode agent --resume'));
+      console.log(chalk.gray('   Status: vibecode agent --status\n'));
+      return;
+    }
+
     printError('Description too short. Please provide more details.');
     console.log(chalk.gray('Example: vibecode agent "SaaS dashboard with auth, billing, and analytics"'));
     process.exit(1);
@@ -33,11 +57,7 @@ export async function agentCommand(description, options = {}) {
 
   // Handle sub-commands
   if (options.analyze) {
-    return analyzeCommand(description, options);
-  }
-
-  if (options.status) {
-    return statusCommand(options);
+    return analyzeCommand(desc, options);
   }
 
   if (options.report) {
@@ -49,7 +69,7 @@ export async function agentCommand(description, options = {}) {
   }
 
   // Main build flow
-  return buildCommand(description, options);
+  return buildCommand(desc, options);
 }
 
 /**
@@ -134,59 +154,133 @@ async function analyzeCommand(description, options) {
 }
 
 /**
- * Show agent status
+ * Show agent status with resume info
  */
-async function statusCommand(options) {
+async function showAgentStatus(options) {
+  const cwd = process.cwd();
+  const progress = await loadProgress(cwd);
+
+  if (!progress) {
+    console.log(chalk.yellow('\n📭 No active agent session.\n'));
+    console.log(chalk.gray('   Start new: vibecode agent "description" --new\n'));
+    return;
+  }
+
+  console.log();
+  console.log(chalk.cyan('╭' + '─'.repeat(68) + '╮'));
+  console.log(chalk.cyan('│') + chalk.bold.white('   🤖 AGENT STATUS') + ' '.repeat(50) + chalk.cyan('│'));
+  console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+
+  const projectLine = `   Project: ${progress.projectName}`;
+  console.log(chalk.cyan('│') + chalk.white(projectLine) + ' '.repeat(Math.max(0, 66 - projectLine.length)) + chalk.cyan('│'));
+
+  const completed = progress.completedModules?.length || progress.currentModule || 0;
+  const progressLine = `   Progress: ${completed}/${progress.totalModules} modules`;
+  console.log(chalk.cyan('│') + chalk.white(progressLine) + ' '.repeat(Math.max(0, 66 - progressLine.length)) + chalk.cyan('│'));
+
+  console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+
+  // Show modules with status
+  for (const mod of progress.modules || []) {
+    let icon, color;
+    switch (mod.status) {
+      case 'done':
+        icon = chalk.green('✓');
+        color = chalk.green;
+        break;
+      case 'building':
+        icon = chalk.yellow('◐');
+        color = chalk.yellow;
+        break;
+      case 'failed':
+        icon = chalk.red('✗');
+        color = chalk.red;
+        break;
+      default:
+        icon = chalk.gray('○');
+        color = chalk.gray;
+    }
+    const modLine = `   ${icon} ${color(mod.name)}`;
+    // Approximate length without ANSI codes
+    const approxLen = 5 + mod.name.length;
+    console.log(chalk.cyan('│') + modLine + ' '.repeat(Math.max(0, 66 - approxLen)) + chalk.cyan('│'));
+  }
+
+  if (progress.error) {
+    console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+    const errorLine = `   Error: ${progress.error.substring(0, 55)}`;
+    console.log(chalk.cyan('│') + chalk.red(errorLine) + ' '.repeat(Math.max(0, 66 - errorLine.length)) + chalk.cyan('│'));
+  }
+
+  console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+
+  const timeLine = `   Last updated: ${new Date(progress.lastUpdated).toLocaleString()}`;
+  console.log(chalk.cyan('│') + chalk.gray(timeLine) + ' '.repeat(Math.max(0, 66 - timeLine.length)) + chalk.cyan('│'));
+
+  console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+  console.log(chalk.cyan('│') + chalk.yellow('   💡 Resume: vibecode agent --resume') + ' '.repeat(29) + chalk.cyan('│'));
+  console.log(chalk.cyan('│') + ' '.repeat(68) + chalk.cyan('│'));
+  console.log(chalk.cyan('╰' + '─'.repeat(68) + '╯'));
+  console.log();
+
+  // Output JSON if requested
+  if (options.json) {
+    console.log(JSON.stringify(progress, null, 2));
+  }
+}
+
+/**
+ * Resume agent from last stopped module
+ */
+async function resumeCommand(options) {
+  const cwd = process.cwd();
+
+  // Check for progress
+  const progress = await loadProgress(cwd);
+  if (!progress) {
+    console.log(chalk.yellow('\n📭 No session to resume.\n'));
+    console.log(chalk.gray('   Start new: vibecode agent "description" --new\n'));
+    return;
+  }
+
+  // Create agent and resume
   const agent = createAgent({
-    projectPath: process.cwd()
+    projectPath: cwd,
+    verbose: options.verbose || false
   });
 
   try {
-    await agent.initialize();
-    const status = agent.getStatus();
-
-    console.log();
-    console.log(chalk.cyan('Agent Status'));
-    console.log(chalk.gray('─'.repeat(40)));
-    console.log();
-
-    console.log(`  Initialized:  ${status.initialized ? chalk.green('Yes') : chalk.red('No')}`);
-    console.log(`  Project:      ${status.projectPath}`);
-
-    if (status.memoryStats) {
-      console.log();
-      console.log(chalk.cyan('Memory Stats'));
-      console.log(chalk.gray('─'.repeat(40)));
-      console.log(`  Modules:      ${status.memoryStats.modulesCompleted}/${status.memoryStats.modulesTotal} completed`);
-      console.log(`  Decisions:    ${status.memoryStats.decisionsCount}`);
-      console.log(`  Patterns:     ${status.memoryStats.patternsCount}`);
-      console.log(`  Errors:       ${status.memoryStats.errorsFixed}/${status.memoryStats.errorsTotal} fixed`);
-      console.log(`  Files:        ${status.memoryStats.filesCreated}`);
-    }
+    // Determine from module
+    const fromModule = options.from ? parseInt(options.from) - 1 : undefined;
 
-    if (status.healingStats) {
-      console.log();
-      console.log(chalk.cyan('Self-Healing Stats'));
-      console.log(chalk.gray('─'.repeat(40)));
-      console.log(`  Attempts:     ${status.healingStats.total}`);
-      console.log(`  Success:      ${status.healingStats.successful}`);
-      console.log(`  Failed:       ${status.healingStats.failed}`);
-      console.log(`  Rate:         ${status.healingStats.successRate}`);
-    }
+    const resumeOptions = {
+      maxModuleRetries: options.maxRetries || 3,
+      testAfterEachModule: !options.skipTests,
+      continueOnFailure: options.continue || false,
+      fromModule
+    };
 
-    console.log();
+    const result = await agent.resume(resumeOptions);
 
-    // Output JSON if requested
-    if (options.json) {
-      console.log(JSON.stringify(status, null, 2));
+    // Exit with appropriate code
+    if (result && !result.success) {
+      process.exit(1);
     }
 
   } catch (error) {
-    printError(`Status failed: ${error.message}`);
+    printError(`Resume failed: ${error.message}`);
+    console.log(chalk.gray('Check .vibecode/agent/orchestrator.log for details.'));
     process.exit(1);
   }
 }
 
+/**
+ * Legacy status command (for compatibility)
+ */
+async function statusCommand(options) {
+  return showAgentStatus(options);
+}
+
 /**
  * Export memory report
  */