@longph2102/v-flow 1.5.0

package/cli/commands/feature.js

@@ -0,0 +1,259 @@
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { isInitialized, getVFlowDir, copyTemplate, listFeatures } = require('../lib/templates');
+const { withErrorHandler, requireInit } = require('../lib/cli-error');
+const { readFlowState } = require('../lib/yaml-parser');
+
+module.exports = function (program) {
+  const feature = program
+    .command('feature')
+    .description('Manage V Flow features');
+
+  // ── v-flow feature create <name> ──────────────────────────────────────
+  feature
+    .command('create')
+    .description('Create a new feature with scaffolded artifacts')
+    .argument('<name>', 'Feature name (e.g. "user-login" or "001-user-login")')
+    .option('--type <type>', 'Project type: greenfield or legacy', 'greenfield')
+    .option('--no-session', 'Skip creating _session.md')
+    .action(withErrorHandler(async (name, options) => {
+      const projectRoot = process.cwd();
+      requireInit(projectRoot, isInitialized);
+
+      const mfDir = getVFlowDir(projectRoot);
+      const featuresDir = path.join(mfDir, 'features');
+
+      // Auto-prefix with next number if name doesn't start with digits
+      let featureDirName = name;
+      if (!/^\d{3}/.test(name)) {
+        const existing = await listFeatures(projectRoot);
+        const nextNum = existing.length > 0
+          ? Math.max(...existing.map(f => parseInt(f.split('-')[0]) || 0)) + 1
+          : 1;
+        featureDirName = `${String(nextNum).padStart(3, '0')}-${name}`;
+      }
+
+      const featureDir = path.join(featuresDir, featureDirName);
+
+      // Check if feature already exists
+      if (fs.existsSync(featureDir)) {
+        console.log(chalk.yellow(`\n⚠️  Feature "${featureDirName}" already exists.`));
+        console.log(chalk.dim(`   Path: ${featureDir}\n`));
+        return;
+      }
+
+      console.log(chalk.cyan.bold(`\n🆕 Creating feature: ${featureDirName}\n`));
+
+      // Create feature directory
+      await fs.ensureDir(featureDir);
+      console.log(chalk.green(`   ✅ Directory created: .v-flow/features/${featureDirName}/`));
+
+      const today = new Date().toISOString().split('T')[0];
+      const featureDisplayName = featureDirName.replace(/^\d+-/, '').replace(/-/g, ' ');
+      const featureId = featureDirName.split('-')[0];
+
+      // 1. Create spec.md from template
+      const specDest = path.join(featureDir, 'spec.md');
+      try {
+        await copyTemplate('spec-template.md', specDest, {
+          'TÊN FEATURE': featureDisplayName,
+          'YYYY-MM-DD': today,
+        });
+        console.log(chalk.green('   ✅ spec.md (specification template)'));
+      } catch {
+        // Create minimal spec if template not found
+        await fs.writeFile(specDest, `# Specification — ${featureDisplayName}\n\n> 📌 **Single Source of Truth** — Spec thắng khi có conflict với plan/tasks/tests.\n> Feature: ${featureDisplayName}\n\n## 1. Tổng quan\n\n*(BA Agent sẽ điền khi chạy /v.specify)*\n\n## 7. Status\n\n| Thông tin | Giá trị |\n|-----------|--------|\n| **Spec Version** | v1.0 |\n| **Trạng thái** | Draft |\n| **Ngày tạo** | ${today} |\n`, 'utf8');
+        console.log(chalk.green('   ✅ spec.md (minimal template)'));
+      }
+
+      // 2. Create .flow-state.yaml
+      const flowStateDest = path.join(featureDir, '.flow-state.yaml');
+      const flowStateContent = `# V Flow State — ${featureDirName}
+# Tạo tự động bởi v-flow feature create
+# ⚠️ KHÔNG sửa tay — dùng /v.status để xem
+
+# ── IDENTITY ──
+feature_id: "${featureId}"
+feature_name: "${featureDirName}"
+created_at: "${today}"
+last_updated: "${today}"
+project_type: "${options.type}"
+schema_version: "2.0"   # khớp SCHEMA_VERSION trong cli/commands/validate.js — feature mới phải theo schema hiện hành
+pipeline_type: "full"   # full | quickfix | hotfix — drive "lite" profile của validator
+
+# ── PIPELINE STATE ──
+current_phase: "S.1"
+phase_status: "pending"
+
+phase_history:
+  - phase: "S.1"
+    entered_at: "${today}"
+    exited_at: null
+    reason: "feature created via CLI"
+
+# ── ARTIFACTS ──
+artifacts:
+  spec:
+    exists: true
+    version: "v1.0"
+    status: "draft"
+    human_approved: false
+  plan:
+    exists: false
+    synced_to_spec: null
+    human_approved: false
+  tasks:
+    exists: false
+    synced_to_spec: null
+    total: 0
+    completed: 0
+  test_cases:
+    exists: false
+    synced_to_spec: null
+    total: 0
+    human_approved: false
+  validation_report:
+    exists: false
+    verdict: null
+    concerns_count: 0
+  code_review:
+    exists: false
+    verdict: null
+
+# ── ROUTING ──
+routing:
+  after_master_check:
+    last_verdict: null
+    route_decision: null
+  after_review:
+    last_verdict: null
+    route_decision: null
+
+# ── HUMAN CHECKPOINTS ──
+human_checkpoints:
+  spec_approved: false
+  plan_approved: false
+  master_check_approved: false
+  implementation_approved: false
+  review_approved: false
+
+awaiting_checkpoint: "spec_approved"
+
+# ── CONCERNS ──
+active_concerns: []
+
+# ── BLOCKED ──
+blocked: false
+blocked_reason: null
+
+# ── METADATA ──
+spec_version_latest: "v1.0"
+session_file: ".v-flow/features/${featureDirName}/_session.md"
+notes: ""
+`;
+      await fs.writeFile(flowStateDest, flowStateContent, 'utf8');
+      console.log(chalk.green('   ✅ .flow-state.yaml (pipeline state)'));
+
+      // 3. Create _session.md
+      if (options.session !== false) {
+        const sessionDest = path.join(featureDir, '_session.md');
+        try {
+          await copyTemplate('session-template.md', sessionDest);
+          // Replace placeholders
+          let content = await fs.readFile(sessionDest, 'utf8');
+          content = content
+            .replace(/\[Feature Name\]/g, featureDisplayName)
+            .replace(/NNN-feature-name/g, featureDirName)
+            .replace(/NNN/g, featureId);
+          await fs.writeFile(sessionDest, content, 'utf8');
+          console.log(chalk.green('   ✅ _session.md (working memory)'));
+        } catch {
+          await fs.writeFile(sessionDest, `# Session Memory — ${featureDisplayName}\n\n> Working memory cho feature này.\n\n## 📋 Tóm Tắt Nhanh\n\n\`\`\`\nPhase hiện tại : S.1\nBắt đầu lúc   : ${today}\nSpec version   : v1.0\n\`\`\`\n\n## 🧠 Key Decisions\n\n*(Chưa có)*\n\n## ❓ Open Questions\n\n*(Chưa có)*\n\n## ⚡ Execution Trace\n\n*(Agent sẽ append khi hoàn thành mỗi phase)*\n`, 'utf8');
+          console.log(chalk.green('   ✅ _session.md (minimal template)'));
+        }
+      }
+
+      // Summary
+      console.log(chalk.cyan.bold(`\n🎉 Feature "${featureDirName}" created!\n`));
+      console.log(chalk.white('Files created:'));
+      console.log(chalk.dim(`   📂 .v-flow/features/${featureDirName}/`));
+      console.log(chalk.dim(`   ├── spec.md           ← Write spec here (or run /v.specify)`));
+      console.log(chalk.dim(`   ├── .flow-state.yaml  ← Pipeline state (auto-managed)`));
+      if (options.session !== false) {
+        console.log(chalk.dim(`   └── _session.md       ← Working memory`));
+      }
+      console.log('');
+      console.log(chalk.white('Next steps:'));
+      console.log(chalk.yellow(`  1. Run /v.specify to generate spec from requirements`));
+      console.log(chalk.dim(`  2. Or edit spec.md manually, then run /v.plan`));
+      console.log('');
+    }));
+
+  // ── v-flow feature list ───────────────────────────────────────────────
+  feature
+    .command('list')
+    .alias('ls')
+    .description('List all features and their current phase')
+    .action(withErrorHandler(async () => {
+      const projectRoot = process.cwd();
+      requireInit(projectRoot, isInitialized);
+
+      const features = await listFeatures(projectRoot);
+
+      if (features.length === 0) {
+        console.log(chalk.yellow('\nNo features found.'));
+        console.log(chalk.dim('Create one: v-flow feature create <name>\n'));
+        return;
+      }
+
+      console.log(chalk.cyan.bold(`\n📋 Features (${features.length})\n`));
+
+      const mfDir = getVFlowDir(projectRoot);
+
+      for (const feature of features) {
+        const featureDir = path.join(mfDir, 'features', feature);
+        const flowStatePath = path.join(featureDir, '.flow-state.yaml');
+
+        let phase = '?';
+        let status = '';
+
+        if (fs.existsSync(flowStatePath)) {
+          const flowState = await readFlowState(featureDir);
+          if (flowState) {
+            if (flowState.currentPhase) phase = flowState.currentPhase;
+            if (flowState.phaseStatus) status = flowState.phaseStatus;
+          }
+        } else {
+          // Infer from existing files
+          const hasSpec = fs.existsSync(path.join(featureDir, 'spec.md'));
+          const hasPlan = fs.existsSync(path.join(featureDir, 'plan.md'));
+          const hasTests = fs.existsSync(path.join(featureDir, 'test-cases.md'));
+          const hasValidation = fs.existsSync(path.join(featureDir, 'validation-report.md'));
+          if (!hasSpec) phase = 'S.1';
+          else if (!hasPlan) phase = 'B.0a';
+          else if (!hasTests) phase = 'B.0b';
+          else if (!hasValidation) phase = 'R.0';
+          else phase = 'B.1';
+        }
+
+        const statusIcon = {
+          'pending': '⏳',
+          'in_progress': '🔄',
+          'awaiting_human': '👤',
+          'done': '✅',
+          'blocked': '🚫',
+        }[status] || '📂';
+
+        const phaseColor = phase.startsWith('S') ? chalk.blue
+          : phase.startsWith('B') ? chalk.yellow
+          : phase.startsWith('R') ? chalk.magenta
+          : phase.startsWith('M') ? chalk.green
+          : chalk.cyan;
+
+        console.log(`   ${statusIcon} ${chalk.white.bold(feature)}  ${phaseColor(`[${phase}]`)}  ${chalk.dim(status)}`);
+      }
+
+      console.log('');
+    }));
+};

package/cli/commands/hooks.js

@@ -0,0 +1,163 @@
+/**
+ * v-flow hooks — install / inspect / remove activity-logging lifecycle hooks
+ * for the supported AI coding tools.
+ *
+ * Subcommands:
+ *   v-flow hooks install   [--target <key|all>] — write `v-flow log --hook` hooks
+ *   v-flow hooks status                          — show which tools have it installed
+ *   v-flow hooks uninstall [--target <key|all>] — remove v-flow's hooks (keep user's)
+ *
+ * Each tool's hook calls `v-flow log --hook <provider>`, which logs every agent
+ * tool-use / session boundary into .v-flow/logs/. Configs are merged, never
+ * clobbered, and the operation is idempotent.
+ */
+
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { withErrorHandler, ValidationError, printOk, printWarn, printError, printDim } = require('../lib/cli-error');
+const { isInitialized } = require('../lib/templates');
+const { PROVIDERS, getProvider, mergeConfig, removeConfig, isInstalled } = require('../lib/hook-targets');
+
+module.exports = function (program) {
+  const hooksCmd = program
+    .command('hooks')
+    .description('🪝 Activity-logging hooks for AI tools (claude, cursor, copilot, codex, antigravity)');
+
+  // ── v-flow hooks install ──
+  hooksCmd
+    .command('install')
+    .description('Install v-flow logging hooks into AI tool configs')
+    .option('--target <key>', 'Only this tool (claude|cursor|copilot|codex|antigravity); default all')
+    .option('--abs', 'Use an absolute node + CLI path instead of `v-flow` (avoids PATH issues in GUI IDEs)')
+    .action(
+      withErrorHandler(async (options) => {
+        const projectRoot = process.cwd();
+        const targets = resolveTargets(options.target);
+        const bin = options.abs
+          ? `"${process.execPath}" "${path.resolve(__dirname, '..', 'index.js')}"`
+          : 'v-flow';
+
+        console.log(chalk.cyan.bold('\n🪝 Installing activity-logging hooks\n'));
+
+        let installed = 0;
+        for (const provider of targets) {
+          const filePath = path.join(projectRoot, ...provider.file);
+          const rel = path.relative(projectRoot, filePath) || filePath;
+
+          const existing = await readJsonSafe(filePath);
+          if (existing === PARSE_ERROR) {
+            printError(`${provider.label}: ${rel} is not valid JSON — skipped (won't clobber)`);
+            continue;
+          }
+
+          const merged = mergeConfig(provider, existing || {}, { bin });
+          await fs.ensureDir(path.dirname(filePath));
+          await fs.writeJson(filePath, merged, { spaces: 2 });
+          printOk(`${provider.label} → ${rel}`);
+          installed++;
+        }
+
+        console.log('');
+        printDim(`Installed for ${installed}/${targets.length} tool(s). Hooks call: ${bin} log --hook <provider>`);
+        if (options.abs) {
+          printWarn('Absolute paths are machine-specific — re-run `v-flow hooks install --abs` on each machine; do not commit these configs.');
+        } else {
+          printDim('Tip: `v-flow` must be on PATH for the hook to run. GUI IDEs may not inherit your shell PATH — use --abs if hooks do not fire.');
+        }
+        if (!isInitialized(projectRoot)) {
+          printWarn('No .v-flow/ here yet — hook entries will be logged only after `v-flow init` (or set VFLOW_LOG_DIR).');
+        }
+        console.log('');
+      })
+    );
+
+  // ── v-flow hooks status ──
+  hooksCmd
+    .command('status')
+    .description('Show which AI tools have v-flow logging hooks installed')
+    .action(
+      withErrorHandler(async () => {
+        const projectRoot = process.cwd();
+        console.log(chalk.cyan.bold('\n🪝 Hook status\n'));
+
+        for (const provider of PROVIDERS) {
+          const filePath = path.join(projectRoot, ...provider.file);
+          const rel = path.relative(projectRoot, filePath) || filePath;
+          const existing = await readJsonSafe(filePath);
+
+          let mark;
+          if (existing === PARSE_ERROR) {
+            mark = chalk.red('invalid JSON');
+          } else if (existing && isInstalled(provider, existing)) {
+            mark = chalk.green('✅ installed');
+          } else if (existing) {
+            mark = chalk.yellow('⬜ config exists, no v-flow hook');
+          } else {
+            mark = chalk.dim('— not configured');
+          }
+          console.log(`   ${chalk.white(provider.label.padEnd(16))} ${mark}  ${chalk.dim(rel)}`);
+        }
+        console.log('');
+      })
+    );
+
+  // ── v-flow hooks uninstall ──
+  hooksCmd
+    .command('uninstall')
+    .description("Remove v-flow's logging hooks (leaves your own hooks intact)")
+    .option('--target <key>', 'Only this tool (claude|cursor|copilot|codex|antigravity); default all')
+    .action(
+      withErrorHandler(async (options) => {
+        const projectRoot = process.cwd();
+        const targets = resolveTargets(options.target);
+
+        console.log(chalk.cyan.bold('\n🪝 Removing activity-logging hooks\n'));
+
+        for (const provider of targets) {
+          const filePath = path.join(projectRoot, ...provider.file);
+          const rel = path.relative(projectRoot, filePath) || filePath;
+          const existing = await readJsonSafe(filePath);
+
+          if (existing === PARSE_ERROR) {
+            printError(`${provider.label}: ${rel} is not valid JSON — skipped`);
+            continue;
+          }
+          if (!existing || !isInstalled(provider, existing)) {
+            printDim(`${provider.label}: nothing to remove`);
+            continue;
+          }
+          const stripped = removeConfig(provider, existing);
+          await fs.writeJson(filePath, stripped, { spaces: 2 });
+          printOk(`${provider.label} → removed from ${rel}`);
+        }
+        console.log('');
+      })
+    );
+};
+
+// ── helpers ──────────────────────────────────────────────────────────────
+
+const PARSE_ERROR = Symbol('parse-error');
+
+function resolveTargets(targetKey) {
+  if (!targetKey || targetKey === 'all') return PROVIDERS;
+  const provider = getProvider(targetKey);
+  if (!provider) {
+    throw new ValidationError(
+      `Unknown target: ${targetKey}`,
+      `Valid: ${PROVIDERS.map((p) => p.key).join(', ')}, all`
+    );
+  }
+  return [provider];
+}
+
+/** Read JSON if present; null if missing; PARSE_ERROR sentinel if unparseable. */
+async function readJsonSafe(filePath) {
+  if (!(await fs.pathExists(filePath))) return null;
+  try {
+    return await fs.readJson(filePath);
+  } catch (_) {
+    return PARSE_ERROR;
+  }
+}

package/cli/commands/init.js

@@ -0,0 +1,189 @@
+const path = require('path');
+const chalk = require('chalk');
+const {
+  isInitialized,
+  scaffoldDirectories,
+  copyTemplate,
+  getVFlowDir,
+  scanCodebase,
+  generateContextMd,
+} = require('../lib/templates');
+const { runSync, syncVFlowAssets, selectTargets } = require('../lib/sync-core');
+const { withErrorHandler } = require('../lib/cli-error');
+const { createT } = require('../lib/i18n');
+
+module.exports = function (program) {
+  program
+    .command('init')
+    .description('Initialize V Flow in the current project')
+    .argument('[project-name]', 'Project name (optional)', '')
+    .option('--ai <agents>', 'AI agents to setup: antigravity, copilot, cursor, claude, all (default: all)', 'all')
+    .option('--skip-ai', 'Skip AI agent file setup')
+    .option('--force', 'Force reinitialize (overwrite existing files)')
+    .action(withErrorHandler(async (projectName, options) => {
+      const t = createT();
+      const projectRoot = process.cwd();
+      const sourceRoot = path.resolve(__dirname, '../..');
+
+      console.log(chalk.cyan.bold(`\n${t('init.title')}\n`));
+
+      // Check if already initialized
+      if (isInitialized(projectRoot) && !options.force) {
+        console.log(chalk.yellow(t('init.already_exists')));
+        console.log(chalk.dim(`${t('init.already_exists_hint')  }\n`));
+      }
+
+      // Step 1: Scaffold directories
+      console.log(chalk.white(t('init.creating_dirs')));
+      await scaffoldDirectories(projectRoot);
+      console.log(chalk.green(`   ${t('init.dir_created')}`));
+
+      // Step 2: Copy constitution template
+      const mfDir = getVFlowDir(projectRoot);
+      const constitutionDest = path.join(mfDir, 'constitution.md');
+      const fs = require('fs-extra');
+
+      if (!fs.existsSync(constitutionDest) || options.force) {
+        const today = new Date().toISOString().split('T')[0];
+        await copyTemplate('constitution-template.md', constitutionDest, {
+          'TÊN DỰ ÁN': projectName || path.basename(projectRoot),
+          'YYYY-MM-DD': today,
+        });
+        console.log(chalk.green(`   ${t('init.constitution_created')}`));
+      } else {
+        console.log(chalk.dim(`   ${t('init.constitution_exists')}`));
+      }
+
+      // Step 3: Copy agent-config template
+      const agentConfigDest = path.join(mfDir, 'agent-config.md');
+      if (!fs.existsSync(agentConfigDest) || options.force) {
+        await copyTemplate('agent-config-template.md', agentConfigDest);
+        console.log(chalk.green(`   ${t('init.agent_config_created')}`));
+      } else {
+        console.log(chalk.dim(`   ${t('init.agent_config_exists')}`));
+      }
+
+      // Step 4: Scan codebase & create context.md
+      const contextDest = path.join(mfDir, 'context.md');
+      if (!fs.existsSync(contextDest) || options.force) {
+        process.stdout.write(chalk.white(`\n${t('init.scanning')}`));
+        try {
+          const scan = await scanCodebase(projectRoot);
+          const contextContent = generateContextMd(scan);
+          await fs.writeFile(contextDest, contextContent, 'utf8');
+          process.stdout.write(` ${  chalk.green('✅\n')}`);
+          console.log(chalk.green(`   ${t('init.scan_complete', { count: scan.totalFiles })}`));
+          if (scan.languages.length > 0) {
+            console.log(chalk.dim(t('init.scan_languages', { languages: scan.languages.join(', ') })));
+          }
+          if (scan.frameworks.length > 0) {
+            console.log(chalk.dim(t('init.scan_frameworks', { frameworks: scan.frameworks.join(', ') })));
+          }
+          console.log(chalk.yellow(`   ${t('init.scan_warning')}`));
+        } catch (err) {
+          process.stdout.write(` ${  chalk.yellow(`${t('init.scan_failed')}\n`)}`);
+          await copyTemplate('context-template.md', contextDest);
+          console.log(chalk.dim(`   ${t('init.scan_template')}`));
+        }
+      } else {
+        console.log(chalk.dim(`   ${t('init.context_exists')}`));
+      }
+
+      // Step 5: Seed Knowledge Base
+      const knowledgeDir = path.join(mfDir, 'knowledge');
+      const knowledgeTemplateDir = path.join(sourceRoot, 'templates', 'knowledge');
+
+      const knowledgeFiles = [
+        { template: 'domain-glossary.md', dest: 'domain-glossary.md' },
+        { template: 'patterns.md', dest: 'patterns/v-flow-patterns.md' },
+        { template: 'lessons-learned.md', dest: 'lessons-learned/v-flow-lessons.md' },
+      ];
+
+      let kbCreated = 0;
+      for (const kf of knowledgeFiles) {
+        const destPath = path.join(knowledgeDir, kf.dest);
+        const srcPath = path.join(knowledgeTemplateDir, kf.template);
+        if (!fs.existsSync(destPath) || options.force) {
+          await fs.ensureDir(path.dirname(destPath));
+          if (fs.existsSync(srcPath)) {
+            await fs.copy(srcPath, destPath);
+          }
+          kbCreated++;
+        }
+      }
+      if (kbCreated > 0) {
+        console.log(chalk.green(`   ${t('init.knowledge_seeded', { count: kbCreated })}`));
+      } else {
+        console.log(chalk.dim(`   ${t('init.knowledge_exists')}`));
+      }
+
+      // Step 7: Copy DESIGN.md into .v-flow/DESIGN.md
+      const designDest = path.join(mfDir, 'DESIGN.md');
+      if (!fs.existsSync(designDest) || options.force) {
+        await copyTemplate('DESIGN.md', designDest);
+        console.log(chalk.green(`   ✅ Design system: .v-flow/DESIGN.md`));
+      } else {
+        console.log(chalk.dim(`   .v-flow/DESIGN.md already exists`));
+      }
+
+      // Step 8: Scaffold CI gate — runs `v-flow validate --strict` on PRs so
+      // spec/plan/tasks can't drift. Without this the validator gates nothing.
+      const ciDest = path.join(projectRoot, '.github', 'workflows', 'v-flow-validate.yml');
+      if (!fs.existsSync(ciDest) || options.force) {
+        await fs.ensureDir(path.dirname(ciDest));
+        await copyTemplate('github/workflows/v-flow-validate.yml', ciDest);
+        console.log(chalk.green('   ✅ CI gate: .github/workflows/v-flow-validate.yml'));
+      } else {
+        console.log(chalk.dim('   .github/workflows/v-flow-validate.yml already exists'));
+      }
+
+      // Step 6: Sync AI agent files using shared sync-core
+      if (!options.skipAi) {
+        console.log(chalk.white(`\n${t('init.syncing')}`));
+
+        const ai = options.ai.toLowerCase();
+
+        // Use the shared sync engine — same logic as `v-flow sync --apply`
+        const stats = await runSync({
+          projectRoot,
+          sourceRoot,
+          dryRun: false,
+          verbose: false,
+          target: ai,
+          silent: true,
+        });
+
+        // Per-target summary — derived from the same registry runSync walks,
+        // so a new vendor shows up here automatically (no edits needed).
+        for (const tgt of selectTargets(ai)) {
+          const cmdDir = path.join(projectRoot, ...tgt.commands.dir);
+          const ext = tgt.commands.ext || '.md';
+          const cmdCount = fs.existsSync(cmdDir)
+            ? (await fs.readdir(cmdDir)).filter(f => f.endsWith(ext)).length
+            : 0;
+          const globals = (tgt.globals || []).map(g => path.join(...g.dest)).join(', ');
+          console.log(chalk.green(`   ✅ ${tgt.label}: ${globals}`));
+          console.log(chalk.green(`      ${path.join(...tgt.commands.dir)}/ (${cmdCount} slash commands) + agents + skills`));
+        }
+
+        console.log(chalk.green('   ✅ Templates: .v-flow/templates/ (all templates synced)'));
+        console.log(chalk.dim(`\n   ${t('init.sync_stats', { added: stats.added, synced: stats.synced, skipped: stats.skipped })}`));
+      } else {
+        // --skip-ai bỏ qua file AI-tool, NHƯNG vẫn cài runtime assets (.v-flow/templates + skills)
+        // để agent path `.v-flow/...` resolve được (chúng là framework runtime, không phải AI files).
+        const assets = await syncVFlowAssets({ projectRoot, sourceRoot, dryRun: false });
+        console.log(chalk.green(`   ✅ Runtime assets → .v-flow/ (${assets.templates} templates + ${assets.skills} skill files; AI agent files skipped)`));
+      }
+
+      // Summary
+      console.log(chalk.cyan.bold(`\n${t('init.complete')}\n`));
+      console.log(chalk.white(t('init.next_steps')));
+      console.log(chalk.yellow(`  ${t('init.review_context')}`));
+      console.log(chalk.dim(`  ${t('init.edit_constitution')}`));
+      console.log(chalk.dim(`  ${t('init.edit_agent_config')}`));
+      console.log(chalk.dim(`  ${t('init.import_ba_docs')}`));
+      console.log(chalk.dim(`  ${t('init.start_feature')}`));
+      console.log(chalk.dim(`  ${t('init.sync_hint')}`));
+      console.log('');
+    }));
+};