jumpstart-mode 1.1.11 → 1.1.13

package/bin/cli.js

@@ -125,6 +125,7 @@ function showHelp() {
   console.log('  timeline             View, query, export, or clear interaction timeline');
   console.log('  validate-all         Proactive validation & suggestion engine');
   console.log('  quickstart           5-minute quickstart wizard');
+  console.log('  focus <action>       Phase focus mode (set/list/clear/status)');
   console.log('  rewind <phase>       Rewind to target phase, archiving downstream artifacts');
   console.log('  approve [path]       Approve current or specified phase artifact');
   console.log('  reject [path]        Reject artifact with reason');
@@ -136,7 +137,106 @@ function showHelp() {
   console.log('  integrate            Rebuild skill integration files');
   console.log('  update [item]        Update installed items to latest');
   console.log('  upgrade              Safely upgrade framework files (preserves user content)');
-  console.log('  upgrade --restore    Restore files from upgrade backups\n');
+  console.log('  upgrade --restore    Restore files from upgrade backups');
+  console.log('  multi-repo <action>  Multi-repo program orchestration (init/status/link/plan)');
+  console.log('  bidirectional-trace  Bidirectional code-to-spec traceability (scan/report)');
+  console.log('  impact <file>        Agentic change impact analysis');
+  console.log('  repo-graph <action>  Automated repo understanding graph (build/query)');
+  console.log('  memory <action>      Persistent project memory (add/list/search/recall)');
+  console.log('  policy <action>      Enterprise policy engine (check/list/add)');
+  console.log('  branch-workflow      Branch-aware workflow engine (track/status/sync)');
+  console.log('  pr-package <action>  PR-native execution mode (create/list/export)');
+  console.log('  parallel-agents      Multi-agent concurrent execution (run/status/reconcile)');
+  console.log('  role-approval        Human approval workflows with roles (assign/approve/status)');
+  console.log('  requirements-baseline Requirements baseline & change control (freeze/check/impact/status)');
+  console.log('  semantic-diff        Cross-artifact semantic diffing (compare/cross-artifact)');
+  console.log('  backlog-sync         Native backlog synchronization (extract/export/status)');
+  console.log('  delivery-confidence  Delivery confidence scoring (score/project)');
+  console.log('  plan-executor        Rich plan execution engine (init/status/update/verify/reset)');
+  console.log('  fitness-functions    Architectural fitness functions (evaluate/add/list)');
+  console.log('  reference-arch       Org-wide reusable reference architectures (list/get/register/instantiate)');
+  console.log('  decision-conflicts   Decision conflict detection (detect)');
+  console.log('  spec-maturity        Spec maturity model (assess/project)');
+  console.log('  portfolio            Portfolio reporting layer (register/status/refresh/snapshot/remove)');
+  console.log('  ci-cd-integration    CI/CD pipeline integration (generate/validate/status)');
+  console.log('  env-promotion        Environment promotion governance (promote/gate/status)');
+  console.log('  raci-matrix          RACI-aware approvals (define/check/report)');
+  console.log('  compliance-packs     Compliance framework packs (list/apply/check)');
+  console.log('  evidence-collector   Evidence collection automation (collect/package/status)');
+  console.log('  release-readiness    Release readiness reviews (assess/report)');
+  console.log('  waiver-workflow      Exception & waiver workflow (request/approve/list/expire)');
+  console.log('  sla-slo              SLA & SLO specification (define/check/report)');
+  console.log('  risk-register        Risk register tracking (add/update/list/report)');
+  console.log('  data-classification  Data classification controls (classify/check/report)');
+  console.log('  credential-boundary  Secrets & credential boundary checks (scan/report)');
+  console.log('  ea-review-packet     Enterprise architecture review packet (generate)');
+  console.log('  model-governance     Model governance workflows (register/evaluate/report)');
+  console.log('  ai-intake            AI use case intake templates (create/list/assess)');
+  console.log('  finops-planner       FinOps-aware architecture planning (estimate/optimize/report)');
+  console.log('  vendor-risk          Vendor & dependency risk scoring (scan/assess/report)');
+  console.log('  cab-output           Change advisory board output (generate)');
+  console.log('  bcdr-planning        Business continuity & DR planning (define/check/report)');
+  console.log('  ops-ownership        Operational ownership modeling (define/check/report)');
+  console.log('  governance-dashboard Governance dashboards for leadership');
+  console.log('  codebase-retrieval   Codebase-native retrieval layer (index/query)');
+  console.log('  ast-edit             AST-aware edit engine (analyze/validate)');
+  console.log('  refactor-planner     Refactor planner with dependency safety (plan/validate/report)');
+  console.log('  test-generator       Test generation from acceptance criteria (generate/coverage)');
+  console.log('  contract-first       Contract-first implementation assistant (extract/verify)');
+  console.log('  runtime-debugger     Runtime-aware debugging mode (analyze/correlate)');
+  console.log('  migration-planner    Brownfield migration planner (plan/status/report)');
+  console.log('  legacy-modernizer    Legacy code modernization mode (assess/plan/report)');
+  console.log('  db-evolution         Database evolution planner (plan/validate/report)');
+  console.log('  safe-rename          Safe large-scale rename & move engine (plan/validate)');
+  console.log('  dependency-upgrade   Dependency upgrade autopilot (scan/plan/report)');
+  console.log('  incident-feedback    Incident-to-spec feedback loop (log/analyze/report)');
+  console.log('  context-chunker      Implementation chunking by context window (chunk/estimate)');
+  console.log('  model-router         Multi-model routing (route/config/report)');
+  console.log('  cost-router          Cost-aware model routing (route/budget/report)');
+  console.log('  deterministic        Deterministic artifact generation (normalize/verify)');
+  console.log('  agent-checkpoint     Agent self-checkpoint & resume (save/restore/list/clean)');
+  console.log('  tool-guardrails      Tool execution guardrails (check/validate)');
+  console.log('  root-cause           Root cause analysis for failures (analyze/report)');
+  console.log('  quality-graph        Code quality smell graph (scan/report)');
+  console.log('  web-dashboard        Rich web UI / local dashboard (config/data/status)');
+  console.log('  role-views           Role-based project views (generate/list)');
+  console.log('  spec-comments        Inline spec review comments (add/resolve/list)');
+  console.log('  workshop-mode        Live workshop mode (start/status)');
+  console.log('  collaboration        Real-time collaboration sessions (create/status)');
+  console.log('  elicitation          Facilitated Q&A with structured elicitation (start/report)');
+  console.log('  enterprise-templates Guided enterprise templates (list/get/apply)');
+  console.log('  playback-summaries   Stakeholder playback summaries (generate/list)');
+  console.log('  design-system        Design system integration (register/check/report)');
+  console.log('  diagram-studio       Diagram studio (generate/validate/compare/list)');
+  console.log('  ambiguity-heatmap    Requirement ambiguity heatmap (scan/report)');
+  console.log('  estimation-studio    Feature estimation studio (estimate/report/calibrate)');
+  console.log('  guided-handoff       Guided handoff packages by team (generate/list/validate)');
+  console.log('  transcript-ingestion Meeting transcript ingestion (ingest/extract/list)');
+  console.log('  chat-integration     Slack and Teams integration (configure/notify)');
+  console.log('  context-onboarding   Context-aware onboarding (generate/customize)');
+  console.log('  promptless-mode      Promptless wizard mode (start/step/status)');
+  console.log('  artifact-comparison  Artifact comparison across versions (compare/history)');
+  console.log('  workstream-ownership Workstream ownership visualization (define/query/report)');
+  console.log('  persona-packs        Persona packs for enterprise roles (list/get/apply)');
+  console.log('  knowledge-graph      Knowledge graph across initiatives (add/query/report)');
+  console.log('  pattern-library      Inner-source pattern library (register/search/get/list)');
+  console.log('  domain-ontology      Domain ontology support (define/query/validate/report)');
+  console.log('  data-contracts       Data contract governance (register/validate/lineage/report)');
+  console.log('  event-modeling       Event-driven architecture modeling (define/validate/report)');
+  console.log('  platform-engineering Platform engineering integration (register/list/instantiate/report)');
+  console.log('  ai-evaluation        AI system evaluation framework (evaluate/report/configure)');
+  console.log('  prompt-governance    Prompt and agent version governance (register/version/approve/list)');
+  console.log('  sre-integration      SRE integration (generate/configure/report)');
+  console.log('  telemetry-feedback   Production telemetry feedback loop (ingest/analyze/report)');
+  console.log('  enterprise-search    Enterprise search over artifacts (index/search)');
+  console.log('  revert <path>        Archive rejected artifact draft and restore previous version');
+  console.log('  adr <action>         Search/index Architecture Decision Records (build/search)');
+  console.log('  complexity [path]    Calculate adaptive planning depth (quick/standard/deep)');
+  console.log('  crossref [dir]       Validate markdown cross-references and detect orphans');
+  console.log('  init                 Interactive initialization wizard (skill level, preferences)');
+  console.log('  lock <action>        Artifact file locking for concurrent agents (acquire/release/list)');
+  console.log('  timestamp <action>   UTC timestamp utilities (now/validate/audit)');
+  console.log('  scan [dir]           Discover project context and tech stack\n');
   console.log(chalk.bold('OPTIONS:'));
   console.log('  <directory>        Target directory (default: current directory)');
   console.log('  --name <name>      Set project name in config');
@@ -176,6 +276,11 @@ function showHelp() {
   console.log('  npx jumpstart-mode checkpoint restore cp-1234567890');
   console.log('  npx jumpstart-mode handoff');
   console.log('  npx jumpstart-mode handoff --output ./export/handoff.md --json');
+  console.log('  npx jumpstart-mode focus list');
+  console.log('  npx jumpstart-mode focus set business-analyst');
+  console.log('  npx jumpstart-mode focus set --start 1 --end 2');
+  console.log('  npx jumpstart-mode focus status');
+  console.log('  npx jumpstart-mode focus clear');
   console.log('  npx jumpstart-mode upgrade');
   console.log('  npx jumpstart-mode upgrade --dry-run');
   console.log('  npx jumpstart-mode upgrade --restore\n');
@@ -698,6 +803,42 @@ async function install(config) {
   const qaLogDest = path.join(targetPath, 'specs', 'qa-log.md');
   copyFile(qaLogSrc, qaLogDest, copyOptions);
 
+  // 4c. Seed timeline and usage log if they don't already exist
+  if (!config.dryRun) {
+    const timelinePath = path.join(targetPath, JUMPSTART_DIR, 'state', 'timeline.json');
+    if (!fs.existsSync(timelinePath)) {
+      const stateDir = path.join(targetPath, JUMPSTART_DIR, 'state');
+      if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+      const sessionId = `ses-init-${Date.now().toString(36)}`;
+      const now = new Date().toISOString();
+      const seed = {
+        version: '1.0.0',
+        session_id: sessionId,
+        started_at: now,
+        ended_at: now,
+        events: [{
+          id: `evt-init-${Date.now().toString(36)}`,
+          timestamp: now,
+          session_id: sessionId,
+          phase: 'init',
+          agent: 'System',
+          parent_agent: null,
+          event_type: 'phase_start',
+          action: 'Jump Start framework initialized — workspace scaffolded',
+          metadata: { project_type: config.projectType || 'unknown', config_path: '.jumpstart/config.yaml' },
+          duration_ms: null
+        }]
+      };
+      fs.writeFileSync(timelinePath, JSON.stringify(seed, null, 2) + '\n', 'utf8');
+      stats.created.push(timelinePath);
+    }
+    const usageLogPath = path.join(targetPath, JUMPSTART_DIR, 'usage-log.json');
+    if (!fs.existsSync(usageLogPath)) {
+      fs.writeFileSync(usageLogPath, JSON.stringify({ entries: [], total_tokens: 0, total_cost_usd: 0 }, null, 2) + '\n', 'utf8');
+      stats.created.push(usageLogPath);
+    }
+  }
+
   // 5-6. Persist bootstrap answers in config.yaml
   const configPath = path.join(targetPath, JUMPSTART_DIR, 'config.yaml');
   const hasBootstrapAnswers = Boolean(config.projectName || config.projectType || config.approverName);
@@ -1671,6 +1812,92 @@ async function main() {
       return;
     }
 
+    if (subcommand === 'focus') {
+      // Phase focus mode — restrict workflow to specific phases
+      const { listPresets, buildFocusConfig, writeFocusToConfig, clearFocusFromConfig, getFocusStatus, VALID_PRESETS } = await import('./lib/focus.js');
+      const action = process.argv[3];
+      const io = require('./lib/io');
+      const configPath = path.join(process.cwd(), '.jumpstart', 'config.yaml');
+
+      if (action === 'list') {
+        const presets = listPresets();
+        io.writeResult({ presets });
+        return;
+      }
+
+      if (action === 'set') {
+        const arg = process.argv[4];
+        const startIdx = process.argv.indexOf('--start');
+        const endIdx = process.argv.indexOf('--end');
+
+        let focusConfig;
+        if (startIdx !== -1 && endIdx !== -1) {
+          // Custom range: focus set --start 1 --end 2
+          const start = parseInt(process.argv[startIdx + 1], 10);
+          const end = parseInt(process.argv[endIdx + 1], 10);
+          if (isNaN(start) || isNaN(end)) {
+            console.error(chalk.red('Usage: jumpstart-mode focus set --start <phase> --end <phase>'));
+            process.exit(1);
+          }
+          try {
+            focusConfig = buildFocusConfig({ start_phase: start, end_phase: end });
+          } catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+          }
+        } else if (arg && !arg.startsWith('-')) {
+          // Preset: focus set business-analyst
+          if (!VALID_PRESETS.includes(arg)) {
+            console.error(chalk.red(`Unknown preset: "${arg}". Valid presets: ${VALID_PRESETS.join(', ')}`));
+            process.exit(1);
+          }
+          focusConfig = buildFocusConfig({ preset: arg });
+        } else {
+          console.error(chalk.red('Usage: jumpstart-mode focus set <preset> | focus set --start <phase> --end <phase>'));
+          console.error(chalk.gray(`  Presets: ${VALID_PRESETS.join(', ')}`));
+          process.exit(1);
+        }
+
+        if (!fs.existsSync(configPath)) {
+          console.error(chalk.red('Config file not found. Run jumpstart-mode init first.'));
+          process.exit(1);
+        }
+
+        const writeResult = writeFocusToConfig(configPath, focusConfig);
+        if (!writeResult.success) {
+          console.error(chalk.red(writeResult.error));
+          process.exit(1);
+        }
+
+        console.log(chalk.green(`Focus mode set: ${focusConfig.description}`));
+        if (focusConfig.phases) {
+          console.log(chalk.gray(`  Phases: ${focusConfig.phases.map(p => p.name || p).join(' → ')}`));
+        }
+        return;
+      }
+
+      if (action === 'clear') {
+        if (!fs.existsSync(configPath)) {
+          console.error(chalk.red('Config file not found. Run jumpstart-mode init first.'));
+          process.exit(1);
+        }
+        clearFocusFromConfig(configPath);
+        console.log(chalk.green('Focus mode cleared — full workflow restored.'));
+        return;
+      }
+
+      if (action === 'status') {
+        const status = getFocusStatus({ root: process.cwd() });
+        io.writeResult(status);
+        return;
+      }
+
+      // Default: show status
+      const status = getFocusStatus({ root: process.cwd() });
+      io.writeResult(status);
+      return;
+    }
+
     if (subcommand === 'summarize') {
       // Smart context summarizer (UX Feature 9)
       const { generateContextPacket, renderContextMarkdown } = require('./lib/context-summarizer');
@@ -2116,6 +2343,2995 @@ async function main() {
       return;
     }
 
+    // ── Feature 1: Multi-Repo Program Orchestration ─────────────────────────
+    if (subcommand === 'multi-repo') {
+      const multiRepo = require('./lib/multi-repo');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+
+      if (action === 'init') {
+        const name = process.argv[4];
+        if (!name) {
+          console.error(chalk.red('Usage: jumpstart-mode multi-repo init <program-name>'));
+          process.exit(1);
+        }
+        const result = multiRepo.initProgram(name, { stateFile: path.join(process.cwd(), '.jumpstart', 'state', 'multi-repo.json') });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ ${result.message}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'link') {
+        const repoUrl = process.argv[4];
+        const role = process.argv[5] || 'other';
+        if (!repoUrl) {
+          console.error(chalk.red('Usage: jumpstart-mode multi-repo link <repo-url> [role]'));
+          process.exit(1);
+        }
+        const result = multiRepo.linkRepo(repoUrl, role, { stateFile: path.join(process.cwd(), '.jumpstart', 'state', 'multi-repo.json') });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Repo linked: ${repoUrl} (${role})`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'plan') {
+        const result = multiRepo.getProgramStatus({ stateFile: path.join(process.cwd(), '.jumpstart', 'state', 'multi-repo.json') });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Program: ${result.program_name || '(not initialized)'}`));
+          console.log(`  Repos: ${result.repo_count}  Shared specs: ${result.shared_spec_count}  Dependencies: ${result.dependency_count}`);
+          if (result.release_plan && result.release_plan.milestones.length > 0) {
+            console.log(`  Milestones: ${result.release_plan.milestones.map(m => m.name).join(', ')}`);
+          }
+          console.log('');
+        }
+      } else {
+        // status (default)
+        const result = multiRepo.getProgramStatus({ stateFile: path.join(process.cwd(), '.jumpstart', 'state', 'multi-repo.json') });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🗂  Multi-Repo Program Status`));
+          console.log(`  Program: ${result.program_name || '(not initialized)'}`);
+          console.log(`  Repos: ${result.repo_count}`);
+          if (result.repo_count > 0) {
+            for (const repo of result.repos) {
+              console.log(`    • [${repo.role}] ${repo.url}`);
+            }
+          }
+          console.log(`  Shared specs: ${result.shared_spec_count}`);
+          console.log(`  Cross-repo deps: ${result.dependency_count}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 2: Bidirectional Code-to-Spec Traceability ──────────────────
+    if (subcommand === 'bidirectional-trace') {
+      const btrace = require('./lib/bidirectional-trace');
+      const action = process.argv[3] || 'scan';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+
+      if (action === 'scan' || action === 'report') {
+        const traceMap = btrace.scanTraceLinks(process.cwd());
+        if (action === 'report') {
+          const report = btrace.buildCoverageReport(process.cwd(), traceMap);
+          if (jsonMode) { io.writeResult(report); } else {
+            console.log(chalk.bold('\n🔗 Bidirectional Traceability Report'));
+            console.log(`  Spec IDs: ${report.total_spec_ids}  Covered: ${report.covered}  Gaps: ${report.gaps}  Coverage: ${report.coverage_pct}%`);
+            if (report.gap_list.length > 0) {
+              console.log(chalk.yellow('\n  Unlinked spec IDs:'));
+              for (const id of report.gap_list) console.log(`    • ${id}`);
+            }
+            console.log('');
+          }
+        } else {
+          if (jsonMode) { io.writeResult(traceMap); } else {
+            console.log(chalk.bold('\n🔗 Trace Scan Complete'));
+            console.log(`  Spec IDs found: ${traceMap.stats.total_spec_ids}`);
+            console.log(`  Files with links: ${traceMap.stats.total_files_with_links}`);
+            console.log(`  Total links: ${traceMap.stats.total_links}`);
+            console.log('');
+          }
+        }
+      } else {
+        console.error(chalk.red('Usage: jumpstart-mode bidirectional-trace [scan|report] [--json]'));
+        process.exit(1);
+      }
+      return;
+    }
+
+    // ── Feature 3: Agentic Change Impact Analysis ────────────────────────────
+    if (subcommand === 'impact') {
+      const { analyzeImpact, renderImpactReport } = require('./lib/impact-analysis');
+      const fileArg = process.argv[3];
+      const symbolIdx = process.argv.indexOf('--symbol');
+      const specIdIdx = process.argv.indexOf('--spec');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+
+      const target = {};
+      if (fileArg && !fileArg.startsWith('--')) target.file = fileArg;
+      if (symbolIdx !== -1) target.symbol = process.argv[symbolIdx + 1];
+      if (specIdIdx !== -1) target.specId = process.argv[specIdIdx + 1];
+
+      if (!target.file && !target.symbol && !target.specId) {
+        console.error(chalk.red('Usage: jumpstart-mode impact <file> [--symbol <name>] [--spec <id>] [--json]'));
+        process.exit(1);
+      }
+
+      const result = analyzeImpact(process.cwd(), target);
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(renderImpactReport(result));
+      }
+      return;
+    }
+
+    // ── Feature 4: Automated Repo Understanding Graph ───────────────────────
+    if (subcommand === 'repo-graph') {
+      const repoGraphLib = require('./lib/repo-graph');
+      const action = process.argv[3] || 'build';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const graphFile = path.join(process.cwd(), '.jumpstart', 'state', 'repo-graph.json');
+
+      if (action === 'build') {
+        const result = repoGraphLib.buildRepoGraph(process.cwd(), { graphFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Repo graph built: ${result.node_count} nodes, ${result.edge_count} edges`));
+          console.log(chalk.gray(`   Saved to: ${result.graph_file}`));
+        }
+      } else if (action === 'query') {
+        const graph = repoGraphLib.loadRepoGraph(graphFile);
+        const typeArg = process.argv.indexOf('--type') !== -1 ? process.argv[process.argv.indexOf('--type') + 1] : null;
+        const nameArg = process.argv.indexOf('--name') !== -1 ? process.argv[process.argv.indexOf('--name') + 1] : null;
+        const results = repoGraphLib.queryGraph(graph, { type: typeArg, nameContains: nameArg });
+        if (jsonMode) { io.writeResult(results); } else {
+          console.log(chalk.bold(`\n🗺  Repo Graph Query (${results.length} nodes)`));
+          for (const n of results) console.log(`  [${n.type}] ${n.id} — ${n.name || ''}`);
+          console.log('');
+        }
+      } else {
+        console.error(chalk.red('Usage: jumpstart-mode repo-graph [build|query] [--type <type>] [--name <name>] [--json]'));
+        process.exit(1);
+      }
+      return;
+    }
+
+    // ── Feature 5: Persistent Long-Term Project Memory ──────────────────────
+    if (subcommand === 'memory') {
+      const memLib = require('./lib/project-memory');
+      const action = process.argv[3] || 'list';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const memFile = path.join(process.cwd(), '.jumpstart', 'state', 'project-memory.json');
+
+      if (action === 'add') {
+        const typeArg = process.argv.indexOf('--type') !== -1 ? process.argv[process.argv.indexOf('--type') + 1] : 'insight';
+        const titleIdx = process.argv.indexOf('--title');
+        const contentIdx = process.argv.indexOf('--content');
+        if (titleIdx === -1 || contentIdx === -1) {
+          console.error(chalk.red('Usage: jumpstart-mode memory add --type <type> --title <title> --content <content>'));
+          process.exit(1);
+        }
+        const result = memLib.addMemory({
+          type: typeArg,
+          title: process.argv[titleIdx + 1],
+          content: process.argv[contentIdx + 1]
+        }, { memoryFile: memFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Memory added: ${result.entry.id}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'search') {
+        const keyword = process.argv[4];
+        if (!keyword) { console.error(chalk.red('Usage: jumpstart-mode memory search <keyword>')); process.exit(1); }
+        const result = memLib.searchMemories(keyword, { memoryFile: memFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🧠 Memory Search: "${keyword}" (${result.total} results)`));
+          for (const e of result.entries) console.log(`  [${e.type}] ${e.title} — ${e.id}`);
+          console.log('');
+        }
+      } else if (action === 'recall') {
+        const id = process.argv[4];
+        if (!id) { console.error(chalk.red('Usage: jumpstart-mode memory recall <id>')); process.exit(1); }
+        const result = memLib.recallMemory(id, { memoryFile: memFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🧠 ${result.entry.title}`));
+            console.log(chalk.gray(`Type: ${result.entry.type}  |  Created: ${result.entry.created_at}`));
+            console.log('');
+            console.log(result.entry.content);
+            console.log('');
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+        }
+      } else {
+        // list (default)
+        const typeFilter = process.argv.indexOf('--type') !== -1 ? process.argv[process.argv.indexOf('--type') + 1] : undefined;
+        const result = memLib.listMemories(typeFilter ? { type: typeFilter } : {}, { memoryFile: memFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🧠 Project Memory (${result.total} entries)`));
+          for (const e of result.entries) console.log(`  [${e.type}] ${e.title} — ${e.id}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 6: Enterprise Policy Engine ────────────────────────────────
+    if (subcommand === 'policy') {
+      const policyLib = require('./lib/policy-engine');
+      const action = process.argv[3] || 'check';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const policyFile = path.join(process.cwd(), '.jumpstart', 'policies.json');
+
+      if (action === 'check') {
+        const result = policyLib.checkPolicies(process.cwd(), { policyFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          const icon = result.summary.passed ? '✅' : '❌';
+          console.log(chalk.bold(`\n${icon} Policy Check: ${result.summary.passed ? 'PASSED' : 'FAILED'}`));
+          console.log(`  Policies checked: ${result.summary.total_policies_checked}`);
+          console.log(`  Violations: ${result.summary.violations}  Warnings: ${result.summary.warnings}`);
+          if (result.violations.length > 0) {
+            console.log(chalk.red('\n  Violations:'));
+            for (const v of result.violations) console.log(`    ❌ [${v.category}] ${v.file}: ${v.policy_name}`);
+          }
+          if (result.warnings.length > 0) {
+            console.log(chalk.yellow('\n  Warnings:'));
+            for (const w of result.warnings) console.log(`    ⚠ [${w.category}] ${w.file}: ${w.policy_name}`);
+          }
+          console.log('');
+        }
+      } else if (action === 'list') {
+        const result = policyLib.listPolicies({}, { policyFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📋 Policies (${result.total})`));
+          for (const p of result.policies) console.log(`  [${p.category}/${p.severity}] ${p.name} — ${p.id}`);
+          console.log('');
+        }
+      } else if (action === 'add') {
+        const nameIdx = process.argv.indexOf('--name');
+        const descIdx = process.argv.indexOf('--desc');
+        const catIdx = process.argv.indexOf('--category');
+        if (nameIdx === -1 || descIdx === -1) {
+          console.error(chalk.red('Usage: jumpstart-mode policy add --name <name> --desc <desc> [--category <cat>] [--severity <sev>]'));
+          process.exit(1);
+        }
+        const sevIdx = process.argv.indexOf('--severity');
+        const patIdx = process.argv.indexOf('--pattern');
+        const result = policyLib.addPolicy({
+          name: process.argv[nameIdx + 1],
+          description: process.argv[descIdx + 1],
+          category: catIdx !== -1 ? process.argv[catIdx + 1] : 'other',
+          severity: sevIdx !== -1 ? process.argv[sevIdx + 1] : 'warning',
+          pattern: patIdx !== -1 ? process.argv[patIdx + 1] : null
+        }, { policyFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Policy added: ${result.policy.id}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else {
+        console.error(chalk.red('Usage: jumpstart-mode policy [check|list|add] [options]'));
+        process.exit(1);
+      }
+      return;
+    }
+
+    // ── Feature 7: Branch-Aware Workflow Engine ─────────────────────────────
+    if (subcommand === 'branch-workflow') {
+      const branchLib = require('./lib/branch-workflow');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+
+      if (action === 'track') {
+        const prNumIdx = process.argv.indexOf('--pr');
+        const result = branchLib.trackBranch(process.cwd(), {
+          pr_number: prNumIdx !== -1 ? parseInt(process.argv[prNumIdx + 1]) : undefined
+        });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Branch tracked: ${result.branch.branch}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'status') {
+        const branchArg = process.argv[4];
+        const result = branchLib.getBranchStatus(process.cwd(), { branch: branchArg });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.tracked) {
+            console.log(chalk.bold(`\n🌿 Branch: ${result.branch}`));
+            console.log(`  Phases recorded: ${result.phase_count}  Approvals: ${result.approved_count}`);
+            if (result.data.pr_number) console.log(`  PR #${result.data.pr_number}`);
+          } else {
+            console.log(chalk.yellow(`\n⚠  ${result.message}`));
+          }
+          console.log('');
+        }
+      } else if (action === 'sync') {
+        const result = branchLib.listTrackedBranches();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🌿 Tracked Branches (${result.total})`));
+          for (const b of result.branches) console.log(`  ${b.branch}  phases=${b.phase_snapshots ? b.phase_snapshots.length : 0}  PR=${b.pr_number || '-'}`);
+          console.log('');
+        }
+      } else {
+        console.error(chalk.red('Usage: jumpstart-mode branch-workflow [track|status|sync] [--pr <number>] [--json]'));
+        process.exit(1);
+      }
+      return;
+    }
+
+    // ── Feature 8: PR-Native Execution Mode ────────────────────────────────
+    if (subcommand === 'pr-package') {
+      const prLib = require('./lib/pr-package');
+      const action = process.argv[3] || 'list';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+
+      if (action === 'create') {
+        const titleIdx = process.argv.indexOf('--title');
+        const summaryIdx = process.argv.indexOf('--summary');
+        const rollbackIdx = process.argv.indexOf('--rollback');
+        const riskIdx = process.argv.indexOf('--risk');
+        if (titleIdx === -1 || summaryIdx === -1) {
+          console.error(chalk.red('Usage: jumpstart-mode pr-package create --title <title> --summary <summary> [--risk <note>] [--rollback <steps>]'));
+          process.exit(1);
+        }
+        const result = prLib.createPRPackage({
+          title: process.argv[titleIdx + 1],
+          summary: process.argv[summaryIdx + 1],
+          risk_notes: riskIdx !== -1 ? [process.argv[riskIdx + 1]] : [],
+          rollback: rollbackIdx !== -1 ? process.argv[rollbackIdx + 1] : undefined
+        }, process.cwd());
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ PR package created: ${result.id}`) : chalk.red(`❌ ${result.error}`));
+          if (result.success) console.log(chalk.gray(`   Saved to: ${result.output_file}`));
+        }
+      } else if (action === 'export') {
+        const packageId = process.argv[4];
+        if (!packageId) { console.error(chalk.red('Usage: jumpstart-mode pr-package export <id>')); process.exit(1); }
+        const result = prLib.exportPRPackage(packageId, process.cwd());
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) { console.log(result.content); } else { console.error(chalk.red(`❌ ${result.error}`)); }
+        }
+      } else {
+        // list (default)
+        const result = prLib.listPRPackages(process.cwd());
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 PR Packages (${result.total})`));
+          for (const p of result.packages) console.log(`  ${p.id}  ${p.created_at.split('T')[0]}  ${p.file}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 9: Multi-Agent Concurrent Execution ─────────────────────────
+    if (subcommand === 'parallel-agents') {
+      const parallelLib = require('./lib/parallel-agents');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'parallel-agents.json');
+
+      if (action === 'run') {
+        const agentsArg = process.argv[4];
+        const agents = agentsArg ? agentsArg.split(',') : [];
+        const result = parallelLib.scheduleRun(agents, { root: process.cwd() }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Run scheduled: ${result.run_id}`) : chalk.red(`❌ ${result.error}`));
+          if (result.success) console.log(chalk.gray(`   Agents: ${result.agents.join(', ')}`));
+        }
+      } else if (action === 'reconcile') {
+        const runId = process.argv[4];
+        if (!runId) { console.error(chalk.red('Usage: jumpstart-mode parallel-agents reconcile <run-id>')); process.exit(1); }
+        const result = parallelLib.reconcileRun(runId, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🔀 Reconciliation: ${runId}`));
+            console.log(`  Total findings: ${result.reconciliation.total_findings}`);
+            console.log(`  Conflicts: ${result.reconciliation.conflicts}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else {
+        // status (default) / list
+        const runs = parallelLib.listRuns({ stateFile });
+        if (jsonMode) { io.writeResult(runs); } else {
+          console.log(chalk.bold(`\n🤖 Parallel Agent Runs (${runs.total})`));
+          for (const r of runs.runs) console.log(`  ${r.id}  [${r.status}]  agents=${r.agent_count}  ${r.scheduled_at.split('T')[0]}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 10: Human Approval Workflows with Roles ─────────────────────
+    if (subcommand === 'role-approval') {
+      const roleLib = require('./lib/role-approval');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'role-approvals.json');
+
+      if (action === 'assign') {
+        const artifactArg = process.argv[4];
+        const rolesArg = process.argv[5];
+        if (!artifactArg || !rolesArg) {
+          console.error(chalk.red('Usage: jumpstart-mode role-approval assign <artifact> <role1,role2,...>'));
+          process.exit(1);
+        }
+        const roles = rolesArg.split(',').map(r => ({ role: r.trim(), required: true }));
+        const result = roleLib.assignApprovers(artifactArg, roles, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Approvers assigned to ${result.artifact}`) : chalk.red(`❌ ${result.error}`));
+          if (result.success) console.log(chalk.gray(`   Roles: ${result.approvers.map(a => a.role).join(', ')}`));
+        }
+      } else if (action === 'approve') {
+        const artifactArg = process.argv[4];
+        const roleArg = process.argv[5];
+        if (!artifactArg || !roleArg) {
+          console.error(chalk.red('Usage: jumpstart-mode role-approval approve <artifact> <role> [--approver <name>]'));
+          process.exit(1);
+        }
+        const nameIdx = process.argv.indexOf('--approver');
+        const result = roleLib.recordRoleAction(artifactArg, roleArg, 'approve', {
+          stateFile,
+          approverName: nameIdx !== -1 ? process.argv[nameIdx + 1] : undefined
+        });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Approved [${roleArg}]: ${artifactArg}  Status: ${result.workflow_status}`) : chalk.red(`❌ ${result.error}`));
+          if (result.success && result.pending_roles.length > 0) console.log(chalk.gray(`   Pending: ${result.pending_roles.join(', ')}`));
+        }
+      } else if (action === 'reject') {
+        const artifactArg = process.argv[4];
+        const roleArg = process.argv[5];
+        if (!artifactArg || !roleArg) {
+          console.error(chalk.red('Usage: jumpstart-mode role-approval reject <artifact> <role>'));
+          process.exit(1);
+        }
+        const result = roleLib.recordRoleAction(artifactArg, roleArg, 'reject', { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.yellow(`🚫 Rejected [${roleArg}]: ${artifactArg}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else {
+        // status (default)
+        const artifactArg = process.argv[4];
+        if (artifactArg) {
+          const result = roleLib.getApprovalStatus(artifactArg, { stateFile });
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.has_workflow) {
+              const icon = result.fully_approved ? '✅' : '⏳';
+              console.log(chalk.bold(`\n${icon} Approval Status: ${artifactArg}`));
+              console.log(`  Status: ${result.status}`);
+              if (result.pending_roles.length > 0) console.log(`  Pending: ${result.pending_roles.join(', ')}`);
+              if (result.approved_roles.length > 0) console.log(`  Approved: ${result.approved_roles.join(', ')}`);
+            } else {
+              console.log(chalk.gray(`\n  ${result.message}`));
+            }
+            console.log('');
+          }
+        } else {
+          const result = roleLib.listApprovalWorkflows({}, { stateFile });
+          if (jsonMode) { io.writeResult(result); } else {
+            console.log(chalk.bold(`\n👥 Approval Workflows (${result.total})`));
+            for (const w of result.workflows) console.log(`  [${w.status}] ${w.artifact}  roles=${w.approvers.length}`);
+            console.log('');
+          }
+        }
+      }
+      return;
+    }
+
+    // ── Feature 11: Requirements Baseline & Change Control ────────────────
+    if (subcommand === 'requirements-baseline') {
+      const baselineLib = require('./lib/requirements-baseline');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+
+      if (action === 'freeze') {
+        const result = baselineLib.freezeBaseline(root, {
+          approver: process.argv.includes('--approver') ? process.argv[process.argv.indexOf('--approver') + 1] : undefined
+        });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.green(`\n🔒 Requirements baseline frozen`));
+            console.log(`  Baseline ID: ${result.baseline_id}`);
+            console.log(`  Artifacts frozen: ${result.artifacts_frozen}`);
+            console.log(`  Total requirements: ${result.total_requirements}`);
+            for (const s of result.snapshots) console.log(`    ${s.type}: ${s.requirements} requirements`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else if (action === 'check') {
+        const result = baselineLib.checkBaseline(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.frozen) {
+            const icon = result.drifted ? '⚠️' : '✅';
+            console.log(chalk.bold(`\n${icon} Baseline Check`));
+            console.log(`  Baseline: ${result.baseline_id}`);
+            console.log(`  Changed: ${result.summary.changed}  Unchanged: ${result.summary.unchanged}`);
+            for (const c of result.changes) console.log(`  ${c.severity === 'critical' ? '🔴' : '🟡'} ${c.path}: ${c.change}`);
+          } else { console.log(chalk.gray('\n  No frozen baseline found')); }
+          console.log('');
+        }
+      } else if (action === 'impact') {
+        const artifactPath = process.argv[4];
+        if (!artifactPath) { console.error(chalk.red('Usage: jumpstart-mode requirements-baseline impact <artifact-path>')); process.exit(1); }
+        const result = baselineLib.assessImpact(artifactPath, root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📊 Impact Assessment: ${result.artifact || artifactPath}`));
+          console.log(`  Impact level: ${result.impact}`);
+          if (result.assessment) {
+            console.log(`  Change type: ${result.assessment.change_type}`);
+            if (result.assessment.requires_re_approval) console.log(chalk.yellow('  ⚠️  Requires re-approval'));
+          }
+          console.log('');
+        }
+      } else {
+        const result = baselineLib.getBaselineStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n📋 Requirements Baseline Status'));
+          console.log(`  Frozen: ${result.frozen ? 'Yes' : 'No'}`);
+          console.log(`  Baselines: ${result.total_baselines}`);
+          console.log(`  Pending change requests: ${result.pending_change_requests}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 12: Cross-artifact Semantic Diffing ───────────────────────
+    if (subcommand === 'semantic-diff') {
+      const diffLib = require('./lib/semantic-diff');
+      const action = process.argv[3] || 'cross-artifact';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+
+      if (action === 'compare') {
+        const pathA = process.argv[4];
+        const pathB = process.argv[5];
+        if (!pathA || !pathB) { console.error(chalk.red('Usage: jumpstart-mode semantic-diff compare <file1> <file2>')); process.exit(1); }
+        const result = diffLib.compareFiles(pathA, pathB);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🔍 Semantic Diff`));
+            console.log(`  Similarity: ${result.overall_similarity}%`);
+            console.log(`  Breaking changes: ${result.has_breaking_changes ? 'Yes' : 'No'}`);
+            console.log(`  Sections: +${result.summary.sections_added} -${result.summary.sections_removed} ~${result.summary.sections_modified}`);
+            console.log(`  Requirements: +${result.summary.requirements_added} -${result.summary.requirements_removed}`);
+            console.log(`  APIs: +${result.summary.apis_added} -${result.summary.apis_removed}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else {
+        const result = diffLib.crossArtifactDiff(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🔍 Cross-artifact Semantic Analysis`));
+            console.log(`  Artifacts analyzed: ${result.artifacts_analyzed}`);
+            console.log(`  Inconsistencies: ${result.summary.total_inconsistencies}`);
+            for (const inc of result.inconsistencies) {
+              console.log(`  ⚠️  ${inc.type}: ${inc.upstream} → ${inc.downstream}: ${inc.missing_requirements.length} gaps`);
+            }
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 13: Native Backlog Synchronization ───────────────────────
+    if (subcommand === 'backlog-sync') {
+      const backlogLib = require('./lib/backlog-sync');
+      const action = process.argv[3] || 'extract';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+
+      if (action === 'extract') {
+        const result = backlogLib.extractBacklog(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n📋 Backlog Extraction'));
+          console.log(`  Epics: ${result.epics}  Stories: ${result.stories}  Tasks: ${result.tasks}`);
+          console.log('');
+        }
+      } else if (action === 'export') {
+        const target = process.argv[4];
+        if (!target) { console.error(chalk.red('Usage: jumpstart-mode backlog-sync export <github|jira|azure-devops>')); process.exit(1); }
+        const result = backlogLib.exportBacklog(root, target);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.green(`\n✅ Backlog exported for ${target}`));
+            console.log(`  Items: ${result.items_exported}`);
+            console.log(`  Output: ${result.output}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else {
+        const syncState = backlogLib.loadSyncState(path.join(root, '.jumpstart', 'state', 'backlog-sync.json'));
+        if (jsonMode) { io.writeResult(syncState); } else {
+          console.log(chalk.bold('\n📋 Backlog Sync Status'));
+          console.log(`  Last sync: ${syncState.last_sync || 'never'}`);
+          console.log(`  Exports: ${syncState.export_history.length}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 14: Delivery Confidence Scoring ──────────────────────────
+    if (subcommand === 'delivery-confidence') {
+      const confLib = require('./lib/delivery-confidence');
+      const action = process.argv[3] || 'project';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+
+      if (action === 'score') {
+        const filePath = process.argv[4];
+        if (!filePath) { console.error(chalk.red('Usage: jumpstart-mode delivery-confidence score <file>')); process.exit(1); }
+        const result = confLib.scoreFile(filePath, { root });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n${result.confidence_emoji} Delivery Confidence: ${result.overall_score}% (${result.confidence_level})`));
+            for (const [dim, data] of Object.entries(result.dimensions)) {
+              console.log(`  ${dim}: ${data.score}%`);
+            }
+            if (result.top_gaps.length > 0) console.log(`  Gaps: ${result.top_gaps.join(', ')}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else {
+        const result = confLib.scoreProject(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n${result.project_emoji} Project Confidence: ${result.project_score}% (${result.project_confidence})`));
+            for (const a of result.artifacts) {
+              console.log(`  ${a.confidence_emoji || '○'} ${a.artifact}: ${a.overall_score || 0}%`);
+            }
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 15: Rich Plan Execution Engine ───────────────────────────
+    if (subcommand === 'plan-executor') {
+      const execLib = require('./lib/plan-executor');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const stateFile = path.join(root, '.jumpstart', 'state', 'plan-execution.json');
+
+      if (action === 'init') {
+        const result = execLib.initializeExecution(root, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.green(`\n✅ Plan execution initialized`));
+            console.log(`  Jobs: ${result.total_jobs}`);
+            console.log(`  Milestones: ${result.milestones.join(', ')}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else if (action === 'update') {
+        const jobId = process.argv[4];
+        const status = process.argv[5];
+        if (!jobId || !status) { console.error(chalk.red('Usage: jumpstart-mode plan-executor update <job-id> <status>')); process.exit(1); }
+        const result = execLib.updateJobStatus(jobId, status, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ ${jobId}: ${result.previous_status} → ${result.new_status}`) : chalk.red(`❌ ${result.error}`));
+          console.log('');
+        }
+      } else if (action === 'verify') {
+        const jobId = process.argv[4];
+        if (!jobId) { console.error(chalk.red('Usage: jumpstart-mode plan-executor verify <job-id>')); process.exit(1); }
+        const result = execLib.verifyJob(jobId, root, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? (result.verified ? chalk.green(`✅ ${jobId}: verified`) : chalk.yellow(`⚠️ ${jobId}: verification failed`)) : chalk.red(`❌ ${result.error}`));
+          console.log('');
+        }
+      } else if (action === 'reset') {
+        const result = execLib.resetExecution({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Execution reset (${result.jobs_reset} jobs)`));
+          console.log('');
+        }
+      } else {
+        const result = execLib.getExecutionStatus({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.initialized) {
+            console.log(chalk.bold(`\n⚡ Plan Execution: ${result.progress}%`));
+            console.log(`  Total: ${result.total_jobs}  Completed: ${result.status_counts.completed}  In Progress: ${result.status_counts.in_progress}  Pending: ${result.status_counts.pending}`);
+            if (result.next_tasks.length > 0) {
+              console.log('  Next tasks:');
+              for (const t of result.next_tasks.slice(0, 5)) console.log(`    → ${t.id}: ${t.title}`);
+            }
+          } else { console.log(chalk.gray('\n  No execution plan loaded. Run: jumpstart-mode plan-executor init')); }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 16: Architectural Fitness Functions ──────────────────────
+    if (subcommand === 'fitness-functions') {
+      const fitnessLib = require('./lib/fitness-functions');
+      const action = process.argv[3] || 'evaluate';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const registryFile = path.join(root, '.jumpstart', 'fitness-functions.json');
+
+      if (action === 'add') {
+        const name = process.argv[4];
+        const category = process.argv[5];
+        if (!name || !category) { console.error(chalk.red('Usage: jumpstart-mode fitness-functions add <name> <category> [--pattern <regex>] [--threshold <n>]')); process.exit(1); }
+        const patternIdx = process.argv.indexOf('--pattern');
+        const thresholdIdx = process.argv.indexOf('--threshold');
+        const result = fitnessLib.addFitnessFunction({
+          name,
+          category,
+          description: `Fitness function: ${name}`,
+          pattern: patternIdx !== -1 ? process.argv[patternIdx + 1] : null,
+          threshold: thresholdIdx !== -1 ? parseInt(process.argv[thresholdIdx + 1]) : null
+        }, { registryFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Fitness function added: ${name}`) : chalk.red(`❌ ${result.error}`));
+          console.log('');
+        }
+      } else if (action === 'list') {
+        const result = fitnessLib.listFitnessFunctions({}, { registryFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🏋️ Fitness Functions (${result.total})`));
+          for (const f of result.functions) console.log(`  [${f.enabled ? '✓' : '✗'}] ${f.name} (${f.category})`);
+          console.log('');
+        }
+      } else {
+        const result = fitnessLib.evaluateFitness(root, { registryFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          const icon = result.all_passed ? '✅' : '❌';
+          console.log(chalk.bold(`\n${icon} Fitness Evaluation`));
+          console.log(`  Functions: ${result.summary.total_functions}  Passed: ${result.summary.passed}  Failed: ${result.summary.failed}`);
+          for (const r of result.results.filter(r => !r.passed)) {
+            console.log(`  🔴 ${r.name}: ${r.violations} violations`);
+          }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 17: Org-wide Reusable Reference Architectures ───────────
+    if (subcommand === 'reference-arch') {
+      const refLib = require('./lib/reference-architectures');
+      const action = process.argv[3] || 'list';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+
+      if (action === 'get') {
+        const patternId = process.argv[4];
+        if (!patternId) { console.error(chalk.red('Usage: jumpstart-mode reference-arch get <pattern-id>')); process.exit(1); }
+        const result = refLib.getPattern(patternId);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            const p = result.pattern;
+            console.log(chalk.bold(`\n📐 ${p.name} (${p.category})`));
+            console.log(`  ${p.description}`);
+            console.log(`  Components: ${p.components.join(', ')}`);
+            console.log('  Structure:');
+            for (const [dir, desc] of Object.entries(p.structure || {})) console.log(`    ${dir} — ${desc}`);
+            if (p.nfrs.length > 0) console.log(`  NFRs: ${p.nfrs.join('; ')}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else if (action === 'register') {
+        const name = process.argv[4];
+        const category = process.argv[5];
+        if (!name) { console.error(chalk.red('Usage: jumpstart-mode reference-arch register <name> [category]')); process.exit(1); }
+        const result = refLib.registerPattern({ name, category: category || 'other', description: `Custom pattern: ${name}` });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Pattern registered: ${name}`) : chalk.red(`❌ ${result.error}`));
+          console.log('');
+        }
+      } else if (action === 'instantiate') {
+        const patternId = process.argv[4];
+        if (!patternId) { console.error(chalk.red('Usage: jumpstart-mode reference-arch instantiate <pattern-id>')); process.exit(1); }
+        const result = refLib.instantiatePattern(patternId, root);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.green(`\n✅ Pattern instantiated: ${result.pattern_name}`));
+            console.log(`  Directories created: ${result.directories_created.length}`);
+            console.log(`  Components: ${result.components.join(', ')}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else {
+        const result = refLib.listPatterns();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📐 Reference Architectures (${result.total})`));
+          for (const p of result.patterns) console.log(`  ${p.id} (${p.category}): ${p.name} — ${p.components} components`);
+          console.log(`  Categories: ${result.categories.join(', ')}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 18: Decision Conflict Detection ─────────────────────────
+    if (subcommand === 'decision-conflicts') {
+      const conflictsLib = require('./lib/decision-conflicts');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+
+      const result = conflictsLib.detectConflicts(root);
+      if (jsonMode) { io.writeResult(result); } else {
+        if (result.success) {
+          const icon = result.summary.has_conflicts ? '⚠️' : '✅';
+          console.log(chalk.bold(`\n${icon} Decision Conflict Analysis`));
+          console.log(`  Decisions analyzed: ${result.total_decisions}`);
+          console.log(`  Conflicts found: ${result.summary.total_conflicts}`);
+          for (const c of result.conflicts) {
+            console.log(`  🔸 ${c.type}: ${c.description}`);
+            console.log(`    Sources: ${c.sources.join(', ')}`);
+          }
+        } else { console.error(chalk.red(`❌ ${result.error}`)); }
+        console.log('');
+      }
+      return;
+    }
+
+    // ── Feature 19: Spec Maturity Model ─────────────────────────────────
+    if (subcommand === 'spec-maturity') {
+      const maturityLib = require('./lib/spec-maturity');
+      const action = process.argv[3] || 'project';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+
+      if (action === 'assess') {
+        const filePath = process.argv[4];
+        if (!filePath) { console.error(chalk.red('Usage: jumpstart-mode spec-maturity assess <file>')); process.exit(1); }
+        const result = maturityLib.assessFile(filePath);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n📊 Maturity: L${result.maturity_level} ${result.maturity_name} (${result.overall_score}%)`));
+            for (const [cat, data] of Object.entries(result.category_scores)) {
+              console.log(`  ${cat}: ${data.score}% (${data.passed}/${data.total})`);
+            }
+            if (result.next_level) console.log(`  Next level: L${result.next_level.level} ${result.next_level.name} (need +${result.next_level.points_needed} points)`);
+            if (result.gaps.length > 0) console.log(`  Gaps: ${result.gaps.slice(0, 5).map(g => g.check).join(', ')}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else {
+        const result = maturityLib.assessProject(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n📊 Project Maturity: L${result.project_level} ${result.project_maturity} (${result.project_score}%)`));
+            for (const a of result.artifacts) {
+              console.log(`  L${a.maturity_level || 1} ${a.artifact}: ${a.overall_score || 0}% (${a.maturity_name || 'Draft'})`);
+            }
+            console.log(`  Production-ready: ${result.summary.production_ready}/${result.summary.artifacts_assessed}`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 20: Portfolio Reporting Layer ────────────────────────────
+    if (subcommand === 'portfolio') {
+      const portfolioLib = require('./lib/portfolio-reporting');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const portfolioFile = path.join(process.cwd(), '.jumpstart', 'state', 'portfolio.json');
+
+      if (action === 'register') {
+        const name = process.argv[4];
+        if (!name) { console.error(chalk.red('Usage: jumpstart-mode portfolio register <name> [--path <dir>] [--owner <name>]')); process.exit(1); }
+        const pathIdx = process.argv.indexOf('--path');
+        const ownerIdx = process.argv.indexOf('--owner');
+        const result = portfolioLib.registerInitiative({
+          name,
+          path: pathIdx !== -1 ? process.argv[pathIdx + 1] : null,
+          owner: ownerIdx !== -1 ? process.argv[ownerIdx + 1] : null
+        }, { portfolioFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Initiative registered: ${name}`) : chalk.red(`❌ ${result.error}`));
+          console.log('');
+        }
+      } else if (action === 'refresh') {
+        const initId = process.argv[4];
+        if (!initId) { console.error(chalk.red('Usage: jumpstart-mode portfolio refresh <initiative-id>')); process.exit(1); }
+        const result = portfolioLib.refreshInitiative(initId, { portfolioFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            const i = result.initiative;
+            console.log(chalk.bold(`\n🔄 ${i.name}`));
+            console.log(`  Status: ${i.status}  Phase: ${i.current_phase}  Progress: ${i.phase_progress}%`);
+          } else { console.error(chalk.red(`❌ ${result.error}`)); }
+          console.log('');
+        }
+      } else if (action === 'snapshot') {
+        const result = portfolioLib.takeSnapshot({ portfolioFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Portfolio snapshot taken at ${result.snapshot.taken_at}`));
+          console.log('');
+        }
+      } else if (action === 'remove') {
+        const initId = process.argv[4];
+        if (!initId) { console.error(chalk.red('Usage: jumpstart-mode portfolio remove <initiative-id>')); process.exit(1); }
+        const result = portfolioLib.removeInitiative(initId, { portfolioFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Removed: ${result.removed}`) : chalk.red(`❌ ${result.error}`));
+          console.log('');
+        }
+      } else {
+        const result = portfolioLib.getPortfolioStatus({ portfolioFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📊 Portfolio Status (${result.total_initiatives} initiatives)`));
+          console.log(`  Average progress: ${result.average_progress}%`);
+          console.log(`  On-track: ${result.status_counts['on-track']}  At-risk: ${result.status_counts['at-risk']}  Blocked: ${result.status_counts['blocked']}  Completed: ${result.status_counts['completed']}`);
+          if (result.budget.total > 0) console.log(`  Budget: $${result.budget.spent}/$${result.budget.total} (${Math.round((result.budget.spent/result.budget.total)*100)}%)`);
+          for (const i of result.initiatives) {
+            console.log(`  [${i.status}] ${i.name}: ${i.progress}% (${i.readiness})`);
+          }
+          if (result.blockers.length > 0) {
+            console.log('  Blockers:');
+            for (const b of result.blockers) console.log(`    🔴 ${b.initiative}: ${b.blocker}`);
+          }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 21: CI/CD Integration ─────────────────────────────────────
+    if (subcommand === 'ci-cd-integration') {
+      const lib = require('./lib/ci-cd-integration');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      if (action === 'generate') {
+        const platform = process.argv[4] || 'github-actions';
+        const result = lib.generatePipeline(platform);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Pipeline generated for ${platform}: ${result.path}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'validate') {
+        const result = lib.validatePipeline(process.cwd());
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🔄 CI/CD Pipeline Validation'));
+          for (const p of result.pipelines) console.log(`  ${p.exists ? '✅' : '❌'} ${p.platform}: ${p.path}`);
+          console.log('');
+        }
+      } else {
+        const result = lib.getStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔄 CI/CD Integration Status`));
+          console.log(`  Available checks: ${result.available_checks}`);
+          console.log(`  Pipelines: ${result.pipelines}  Runs: ${result.total_runs}\n`);
+        }
+      }
+      return;
+    }
+
+    // ── Feature 22: Environment Promotion ────────────────────────────────────
+    if (subcommand === 'env-promotion') {
+      const lib = require('./lib/environment-promotion');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'environment-promotion.json');
+      if (action === 'promote') {
+        const target = process.argv[4];
+        if (!target) { console.error(chalk.red('Usage: jumpstart-mode env-promotion promote <environment>')); process.exit(1); }
+        const result = lib.promote(target, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Promoted to ${result.to}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'gate') {
+        const env = process.argv[4];
+        if (!env) { console.error(chalk.red('Usage: jumpstart-mode env-promotion gate <environment>')); process.exit(1); }
+        const result = lib.checkGates(env, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🚦 Gate Status: ${env}`));
+          console.log(`  Passed: ${result.passed.join(', ') || 'none'}`);
+          console.log(`  Pending: ${result.pending.join(', ') || 'none'}\n`);
+        }
+      } else {
+        const result = lib.getStatus({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🌍 Environment Promotion Status`));
+          console.log(`  Current: ${result.current_environment}`);
+          for (const e of result.environments) console.log(`  ${e.ready ? '✅' : '⏳'} ${e.name}: ${e.gates_passed}/${e.gates_total} gates`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 23: RACI Matrix ──────────────────────────────────────────────
+    if (subcommand === 'raci-matrix') {
+      const lib = require('./lib/raci-matrix');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'raci-matrix.json');
+      if (action === 'define') {
+        const artifact = process.argv[4];
+        const accountable = process.argv[5];
+        if (!artifact || !accountable) { console.error(chalk.red('Usage: jumpstart-mode raci-matrix define <artifact> <accountable>')); process.exit(1); }
+        const result = lib.defineAssignment(artifact, { accountable }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ RACI defined for ${artifact}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'check') {
+        const artifact = process.argv[4];
+        const actor = process.argv[5];
+        if (!artifact || !actor) { console.error(chalk.red('Usage: jumpstart-mode raci-matrix check <artifact> <actor>')); process.exit(1); }
+        const result = lib.checkPermission(artifact, actor, 'approve', { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.allowed ? chalk.green(`✅ ${result.reason}`) : chalk.red(`❌ ${result.reason}`));
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📋 RACI Matrix (${result.total_assignments} assignments, ${result.coverage}% coverage)`));
+          for (const row of result.matrix) console.log(`  ${row.artifact}: R=${row.R} A=${row.A} C=${row.C || '-'} I=${row.I || '-'}`);
+          if (result.gaps.length > 0) console.log(chalk.yellow(`  Gaps: ${result.gaps.join(', ')}`));
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 24: Compliance Packs ─────────────────────────────────────────
+    if (subcommand === 'compliance-packs') {
+      const lib = require('./lib/compliance-packs');
+      const action = process.argv[3] || 'list';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'compliance.json');
+      if (action === 'list') {
+        const result = lib.listFrameworks();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Compliance Frameworks (${result.total})`));
+          for (const fw of result.frameworks) console.log(`  ${fw.id}: ${fw.name} (${fw.controls} controls)`);
+          console.log('');
+        }
+      } else if (action === 'apply') {
+        const fw = process.argv[4];
+        if (!fw) { console.error(chalk.red('Usage: jumpstart-mode compliance-packs apply <framework-id>')); process.exit(1); }
+        const result = lib.applyFramework(fw, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Applied ${result.name} (${result.controls_added} controls)`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'check') {
+        const result = lib.checkCompliance({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔍 Compliance Check`));
+          console.log(`  Frameworks: ${result.applied_frameworks?.join(', ') || 'none'}`);
+          console.log(`  Controls: ${result.total_controls || 0}  Compliant: ${result.compliant}\n`);
+        }
+      }
+      return;
+    }
+
+    // ── Feature 25: Evidence Collector ────────────────────────────────────────
+    if (subcommand === 'evidence-collector') {
+      const lib = require('./lib/evidence-collector');
+      const action = process.argv[3] || 'status';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'collect') {
+        const result = lib.collectEvidence(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Collected ${result.items_collected} evidence items`));
+        }
+      } else if (action === 'package') {
+        const result = lib.packageEvidence(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Evidence packaged: ${result.output}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else {
+        const result = lib.getStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Evidence Status: ${result.total_items} items, ${result.collections} collections\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 26: Release Readiness ────────────────────────────────────────
+    if (subcommand === 'release-readiness') {
+      const lib = require('./lib/release-readiness');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'assess') {
+        const result = lib.assessReadiness(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🚀 Release Readiness: ${result.level} (${result.total_score}%)`));
+          console.log(`  Recommendation: ${result.recommendation}`);
+          if (result.blockers.length > 0) console.log(chalk.red(`  Blockers: ${result.blockers.join(', ')}`));
+          console.log('');
+        }
+      } else {
+        const result = lib.generateReport({ stateFile: path.join(root, '.jumpstart', 'state', 'release-readiness.json') });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🚀 Release Readiness Report: ${result.level} (${result.total_score}%)`));
+            for (const cat of result.categories) console.log(`  ${cat.status === 'pass' ? '✅' : cat.status === 'warning' ? '⚠️' : '❌'} ${cat.name}: ${cat.score}%`);
+          } else {
+            console.log(chalk.yellow(`  ${result.error}`));
+          }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 27: Waiver Workflow ──────────────────────────────────────────
+    if (subcommand === 'waiver-workflow') {
+      const lib = require('./lib/waiver-workflow');
+      const action = process.argv[3] || 'list';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'waivers.json');
+      if (action === 'request') {
+        const title = process.argv[4];
+        const owner = process.argv[5];
+        if (!title || !owner) { console.error(chalk.red('Usage: jumpstart-mode waiver-workflow request <title> <owner>')); process.exit(1); }
+        const result = lib.requestWaiver({ title, owner, justification: 'CLI request' }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Waiver requested: ${result.waiver.id}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'approve') {
+        const waiverId = process.argv[4];
+        if (!waiverId) { console.error(chalk.red('Usage: jumpstart-mode waiver-workflow approve <waiver-id>')); process.exit(1); }
+        const result = lib.resolveWaiver(waiverId, 'approve', { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Waiver approved: ${waiverId}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'expire') {
+        const result = lib.expireWaivers({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Expired ${result.expired} waivers`));
+        }
+      } else {
+        const result = lib.listWaivers({}, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📋 Waivers (${result.total})`));
+          for (const w of result.waivers) console.log(`  [${w.status}] ${w.id}: ${w.title} (${w.owner})`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 28: SLA/SLO ──────────────────────────────────────────────────
+    if (subcommand === 'sla-slo') {
+      const lib = require('./lib/sla-slo');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'sla-slo.json');
+      if (action === 'define') {
+        const name = process.argv[4];
+        const service = process.argv[5];
+        const target = process.argv[6];
+        if (!name || !service || !target) { console.error(chalk.red('Usage: jumpstart-mode sla-slo define <name> <service> <target>')); process.exit(1); }
+        const result = lib.defineSLO({ name, service, target: parseFloat(target) }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ SLO defined: ${result.slo.id}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'check') {
+        const result = lib.checkSLOCoverage(process.cwd(), { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📊 SLO Coverage: ${result.defined_slos} SLOs defined`));
+          console.log(`  Architecture mentions SLO: ${result.architecture_mentions_slo}`);
+          console.log(`  PRD mentions SLO: ${result.prd_mentions_slo}\n`);
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📊 SLA/SLO Report: ${result.total_slos} SLOs, ${result.total_slas} SLAs\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 29: Risk Register ────────────────────────────────────────────
+    if (subcommand === 'risk-register') {
+      const lib = require('./lib/risk-register');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'risk-register.json');
+      if (action === 'add') {
+        const title = process.argv[4];
+        if (!title) { console.error(chalk.red('Usage: jumpstart-mode risk-register add <title>')); process.exit(1); }
+        const result = lib.addRisk({ title, description: title }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Risk added: ${result.risk.id} (score: ${result.risk.score})`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'list') {
+        const result = lib.listRisks({}, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n⚠️ Risk Register (${result.total})`));
+          for (const r of result.risks) console.log(`  [${r.status}] ${r.id}: ${r.title} (${r.likelihood}/${r.impact}, score=${r.score})`);
+          console.log('');
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n⚠️ Risk Report: ${result.total_risks} risks, avg score=${result.average_score}`));
+          console.log(`  High: ${result.high_risks}  Unmitigated: ${result.unmitigated}\n`);
+        }
+      }
+      return;
+    }
+
+    // ── Feature 30: Data Classification ──────────────────────────────────────
+    if (subcommand === 'data-classification') {
+      const lib = require('./lib/data-classification');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'data-classification.json');
+      if (action === 'classify') {
+        const name = process.argv[4];
+        if (!name) { console.error(chalk.red('Usage: jumpstart-mode data-classification classify <asset-name>')); process.exit(1); }
+        const result = lib.classifyAsset({ name }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Classified: ${result.asset.classification}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'check') {
+        const result = lib.checkCompliance({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🏷️ Data Classification: ${result.total_assets} assets, ${result.violations} violations\n`));
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🏷️ Data Classification Report: ${result.total_assets} assets`));
+          for (const [level, count] of Object.entries(result.by_level)) console.log(`  ${level}: ${count}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 31: Credential Boundary ──────────────────────────────────────
+    if (subcommand === 'credential-boundary') {
+      const lib = require('./lib/credential-boundary');
+      const action = process.argv[3] || 'scan';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const result = lib.scanProject(root);
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🔐 Credential Boundary Scan`));
+        console.log(`  Files scanned: ${result.files_scanned}`);
+        console.log(`  Findings: ${result.total_findings} (${result.critical} critical, ${result.high} high)`);
+        console.log(`  ${result.pass ? chalk.green('✅ PASS') : chalk.red('❌ FAIL')}\n`);
+      }
+      return;
+    }
+
+    // ── Feature 32: EA Review Packet ─────────────────────────────────────────
+    if (subcommand === 'ea-review-packet') {
+      const lib = require('./lib/ea-review-packet');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const result = lib.generatePacket(process.cwd());
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🏢 EA Review Packet: ${result.completeness}% complete`));
+        for (const [section, data] of Object.entries(result.sections)) console.log(`  ${data.present ? '✅' : '❌'} ${section}`);
+        if (result.gaps.length > 0) console.log(chalk.yellow(`  Gaps: ${result.gaps.join(', ')}`));
+        console.log('');
+      }
+      return;
+    }
+
+    // ── Feature 33: Model Governance ─────────────────────────────────────────
+    if (subcommand === 'model-governance') {
+      const lib = require('./lib/model-governance');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'model-governance.json');
+      if (action === 'register') {
+        const name = process.argv[4];
+        const provider = process.argv[5];
+        if (!name || !provider) { console.error(chalk.red('Usage: jumpstart-mode model-governance register <name> <provider>')); process.exit(1); }
+        const result = lib.registerModel({ name, provider }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Model registered: ${result.model.id}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🤖 Model Governance: ${result.total_models} models, ${result.total_evaluations} evaluations`));
+          if (result.high_risk_models.length > 0) console.log(chalk.yellow(`  High risk: ${result.high_risk_models.map(m => m.name).join(', ')}`));
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 34: AI Intake ────────────────────────────────────────────────
+    if (subcommand === 'ai-intake') {
+      const lib = require('./lib/ai-intake');
+      const action = process.argv[3] || 'list';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'ai-intake.json');
+      if (action === 'create') {
+        const name = process.argv[4];
+        if (!name) { console.error(chalk.red('Usage: jumpstart-mode ai-intake create <name>')); process.exit(1); }
+        const result = lib.createIntake({ name, description: name }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ AI intake created: ${result.intake.id} (Risk tier: ${result.intake.risk_tier})`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else {
+        const result = lib.listIntakes({}, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🧠 AI Use Case Intakes (${result.total})`));
+          for (const i of result.intakes) console.log(`  ${i.id}: ${i.name} (Tier ${i.risk_tier}: ${i.risk_label})`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 35: FinOps Planner ───────────────────────────────────────────
+    if (subcommand === 'finops-planner') {
+      const lib = require('./lib/finops-planner');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'finops.json');
+      if (action === 'optimize') {
+        const result = lib.getOptimizations({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n💰 FinOps Optimizations (${result.total})`));
+          for (const r of result.recommendations) console.log(`  ${r.recommendation} (${r.potential_savings})`);
+          console.log('');
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n💰 FinOps Report: $${result.total_monthly}/mo ($${result.total_annual}/yr)`));
+          console.log(`  Estimates: ${result.total_estimates}\n`);
+        }
+      }
+      return;
+    }
+
+    // ── Feature 36: Vendor Risk ──────────────────────────────────────────────
+    if (subcommand === 'vendor-risk') {
+      const lib = require('./lib/vendor-risk');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const stateFile = path.join(root, '.jumpstart', 'state', 'vendor-risk.json');
+      if (action === 'scan') {
+        const result = lib.scanDependencies(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Vendor Scan: ${result.total} dependencies found\n`));
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Vendor Risk Report: ${result.total_assessed} assessed`));
+          console.log(`  Avg score: ${result.average_score}  High risk: ${result.high_risk.length}\n`);
+        }
+      }
+      return;
+    }
+
+    // ── Feature 37: CAB Output ───────────────────────────────────────────────
+    if (subcommand === 'cab-output') {
+      const lib = require('./lib/cab-output');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const result = lib.generateCABSummary(process.cwd());
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n📋 CAB Summary: ${result.completeness}% complete (Risk: ${result.risk_level})`));
+        console.log(`  ${result.recommendation}`);
+        if (result.gaps.length > 0) console.log(chalk.yellow(`  Gaps: ${result.gaps.join(', ')}`));
+        console.log('');
+      }
+      return;
+    }
+
+    // ── Feature 38: BCDR Planning ────────────────────────────────────────────
+    if (subcommand === 'bcdr-planning') {
+      const lib = require('./lib/bcdr-planning');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const stateFile = path.join(root, '.jumpstart', 'state', 'bcdr.json');
+      if (action === 'define') {
+        const name = process.argv[4];
+        const tier = process.argv[5] || 'silver';
+        if (!name) { console.error(chalk.red('Usage: jumpstart-mode bcdr-planning define <service-name> [tier]')); process.exit(1); }
+        const result = lib.defineService({ name, tier }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ BC/DR defined: RTO=${result.service.rto_hours}h RPO=${result.service.rpo_hours}h`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'check') {
+        const result = lib.checkCoverage(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🛡️ BC/DR Coverage: ${result.coverage}%`));
+          if (result.gaps.length > 0) console.log(chalk.yellow(`  Gaps: ${result.gaps.join(', ')}`));
+          console.log('');
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🛡️ BC/DR Report: ${result.total_services} services\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 39: Ops Ownership ────────────────────────────────────────────
+    if (subcommand === 'ops-ownership') {
+      const lib = require('./lib/ops-ownership');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'ops-ownership.json');
+      if (action === 'define') {
+        const name = process.argv[4];
+        const owner = process.argv[5];
+        if (!name || !owner) { console.error(chalk.red('Usage: jumpstart-mode ops-ownership define <service> <owner>')); process.exit(1); }
+        const result = lib.defineOwnership({ name, service_owner: owner }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Ownership defined for ${name}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'check') {
+        const result = lib.checkCompleteness({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n👤 Ops Ownership: ${result.complete}/${result.total_services} complete\n`));
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n👤 Ops Ownership Report: ${result.total_services} services\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 40: Governance Dashboard ─────────────────────────────────────
+    if (subcommand === 'governance-dashboard') {
+      const lib = require('./lib/governance-dashboard');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const result = lib.gatherGovernanceData(process.cwd());
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(lib.renderDashboardText(result));
+      }
+      return;
+    }
+
+    // ── Feature 41: Codebase Retrieval ───────────────────────────────────────
+    if (subcommand === 'codebase-retrieval') {
+      const lib = require('./lib/codebase-retrieval');
+      const action = process.argv[3] || 'index';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'query') {
+        const query = process.argv[4];
+        if (!query) { console.error(chalk.red('Usage: jumpstart-mode codebase-retrieval query <search-term>')); process.exit(1); }
+        const result = lib.queryFiles(root, query);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔍 Codebase Query: "${query}" (${result.total_results} results)`));
+          for (const r of result.results.slice(0, 10)) console.log(`  ${r.file} (${r.matches} matches)`);
+          console.log('');
+        }
+      } else {
+        const result = lib.indexProject(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📁 Codebase Index: ${result.total_files} files`));
+          for (const c of result.categories) console.log(`  ${c.type}: ${c.count}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 42: AST Edit Engine ──────────────────────────────────────────
+    if (subcommand === 'ast-edit') {
+      const lib = require('./lib/ast-edit-engine');
+      const action = process.argv[3] || 'analyze';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const filePath = process.argv[4];
+      if (!filePath) { console.error(chalk.red('Usage: jumpstart-mode ast-edit analyze|validate <file>')); process.exit(1); }
+      const result = lib.analyzeStructure(filePath);
+      if (jsonMode) { io.writeResult(result); } else {
+        if (result.success) {
+          console.log(chalk.bold(`\n🌳 AST Analysis: ${result.file} (${result.language})`));
+          console.log(`  Lines: ${result.total_lines}  Symbols: ${result.symbol_count}`);
+          for (const s of result.symbols) console.log(`  L${s.line}: ${s.type} ${s.name}`);
+        } else { console.log(chalk.red(`❌ ${result.error}`)); }
+        console.log('');
+      }
+      return;
+    }
+
+    // ── Feature 43: Refactor Planner ─────────────────────────────────────────
+    if (subcommand === 'refactor-planner') {
+      const lib = require('./lib/refactor-planner');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'refactor-plan.json');
+      const result = lib.generateReport({ stateFile });
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🔧 Refactor Planner: ${result.total_plans} plans, ${result.completed} completed\n`));
+      }
+      return;
+    }
+
+    // ── Feature 44: Test Generator ───────────────────────────────────────────
+    if (subcommand === 'test-generator') {
+      const lib = require('./lib/test-generator');
+      const action = process.argv[3] || 'coverage';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'coverage') {
+        const result = lib.checkCoverage(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🧪 Test Coverage vs Acceptance Criteria: ${result.coverage}%`));
+            console.log(`  Total criteria: ${result.total_criteria}  Covered: ${result.covered}`);
+          } else { console.log(chalk.yellow(`  ${result.error}`)); }
+          console.log('');
+        }
+      } else {
+        const prdFile = path.join(root, 'specs', 'prd.md');
+        if (!fs.existsSync(prdFile)) { console.error(chalk.red('PRD not found at specs/prd.md')); process.exit(1); }
+        const content = fs.readFileSync(prdFile, 'utf8');
+        const criteria = lib.extractCriteria(content);
+        const result = lib.generateTestStubs(criteria);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🧪 Test Generator: ${result.test_files} files from ${result.total_criteria} criteria\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 45: Contract First ───────────────────────────────────────────
+    if (subcommand === 'contract-first') {
+      const lib = require('./lib/contract-first');
+      const action = process.argv[3] || 'extract';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'verify') {
+        const result = lib.verifyCompliance(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📝 Contract Compliance: ${result.compliance}%`));
+          console.log(`  Contracts: ${result.total_contracts}  Implemented: ${result.implemented}  Violations: ${result.violations}\n`);
+        }
+      } else {
+        const result = lib.extractContracts(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📝 Contracts Found: ${result.total_contracts}`));
+          for (const c of (result.contracts || [])) console.log(`  ${c.type}: ${c.method || ''} ${c.path || c.name}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 46: Runtime Debugger ─────────────────────────────────────────
+    if (subcommand === 'runtime-debugger') {
+      const lib = require('./lib/runtime-debugger');
+      const action = process.argv[3] || 'analyze';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const filePath = process.argv[4];
+      if (!filePath) { console.error(chalk.red('Usage: jumpstart-mode runtime-debugger analyze <log-file>')); process.exit(1); }
+      const result = lib.analyzeLogFile(filePath);
+      if (jsonMode) { io.writeResult(result); } else {
+        if (result.success) {
+          console.log(chalk.bold(`\n🐛 Log Analysis: ${result.total_findings} findings`));
+          console.log(`  Errors: ${result.summary.errors}  Warnings: ${result.summary.warnings}  Exceptions: ${result.summary.exceptions}\n`);
+        } else { console.log(chalk.red(`❌ ${result.error}`)); }
+      }
+      return;
+    }
+
+    // ── Feature 47: Migration Planner ────────────────────────────────────────
+    if (subcommand === 'migration-planner') {
+      const lib = require('./lib/migration-planner');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'migration-plan.json');
+      const result = lib.generateReport({ stateFile });
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🔄 Migration Planner: ${result.total_migrations} migrations\n`));
+      }
+      return;
+    }
+
+    // ── Feature 48: Legacy Modernizer ────────────────────────────────────────
+    if (subcommand === 'legacy-modernizer') {
+      const lib = require('./lib/legacy-modernizer');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'legacy-modernization.json');
+      const result = lib.generateReport({ stateFile });
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🏚️ Legacy Modernizer: ${result.total_assessments} assessments, ${result.total_plans} plans\n`));
+      }
+      return;
+    }
+
+    // ── Feature 49: DB Evolution ─────────────────────────────────────────────
+    if (subcommand === 'db-evolution') {
+      const lib = require('./lib/db-evolution');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'db-evolution.json');
+      const result = lib.generateReport({ stateFile });
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🗄️ DB Evolution: ${result.total_migrations} migrations\n`));
+      }
+      return;
+    }
+
+    // ── Feature 50: Safe Rename ──────────────────────────────────────────────
+    if (subcommand === 'safe-rename') {
+      const lib = require('./lib/safe-rename');
+      const action = process.argv[3] || 'plan';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'plan') {
+        const oldPath = process.argv[4];
+        const newPath = process.argv[5];
+        if (!oldPath || !newPath) { console.error(chalk.red('Usage: jumpstart-mode safe-rename plan <old-path> <new-path>')); process.exit(1); }
+        const result = lib.planRename(root, oldPath, newPath);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Safe Rename: ${oldPath} → ${newPath}`));
+          console.log(`  References: ${result.references_found}  Files affected: ${result.affected_files.length}\n`);
+        }
+      } else if (action === 'validate') {
+        const oldPath = process.argv[4];
+        const newPath = process.argv[5];
+        if (!oldPath || !newPath) { console.error(chalk.red('Usage: jumpstart-mode safe-rename validate <old-path> <new-path>')); process.exit(1); }
+        const result = lib.validateRename(root, oldPath, newPath);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.clean ? chalk.green('✅ Rename validated') : chalk.yellow(`⚠️ ${result.stale_references} stale references found`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 51: Dependency Upgrade ───────────────────────────────────────
+    if (subcommand === 'dependency-upgrade') {
+      const lib = require('./lib/dependency-upgrade');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'scan') {
+        const result = lib.scanUpgrades(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Dependency Scan: ${result.total} dependencies\n`));
+        }
+      } else {
+        const stateFile = path.join(root, '.jumpstart', 'state', 'dependency-upgrades.json');
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📦 Dependency Upgrade Report: ${result.total_plans} plans\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 52: Incident Feedback ────────────────────────────────────────
+    if (subcommand === 'incident-feedback') {
+      const lib = require('./lib/incident-feedback');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'incidents.json');
+      if (action === 'log') {
+        const title = process.argv[4];
+        const severity = process.argv[5] || 'sev3';
+        if (!title) { console.error(chalk.red('Usage: jumpstart-mode incident-feedback log <title> [severity]')); process.exit(1); }
+        const result = lib.logIncident({ title, severity, description: title }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Incident logged: ${result.incident.id}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else {
+        const result = lib.generateReport({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🚨 Incident Feedback: ${result.total_incidents} incidents, ${result.total_spec_updates} spec updates\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 53: Context Chunker ──────────────────────────────────────────
+    if (subcommand === 'context-chunker') {
+      const lib = require('./lib/context-chunker');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const result = lib.chunkImplementationPlan(root);
+      if (jsonMode) { io.writeResult(result); } else {
+        if (result.success) {
+          console.log(chalk.bold(`\n📦 Context Chunking: ${result.total_sections} sections, ${result.total_tokens} tokens`));
+          for (const r of result.model_recommendations) {
+            console.log(`  ${r.model}: ${r.fits_in_single_call ? '✅ fits' : `needs ${r.chunks_needed} chunks`}`);
+          }
+        } else { console.log(chalk.yellow(`  ${result.error}`)); }
+        console.log('');
+      }
+      return;
+    }
+
+    // ── Feature 54: Model Router ─────────────────────────────────────────────
+    if (subcommand === 'model-router') {
+      const lib = require('./lib/model-router');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      if (action === 'route') {
+        const taskType = process.argv[4];
+        if (!taskType) { console.error(chalk.red('Usage: jumpstart-mode model-router route <task-type>')); process.exit(1); }
+        const result = lib.routeTask(taskType);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Route: ${taskType} → ${result.model} (${result.reason})`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔀 Model Router: ${result.unique_models} models across ${result.task_types} task types\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 55: Cost Router ──────────────────────────────────────────────
+    if (subcommand === 'cost-router') {
+      const lib = require('./lib/cost-router');
+      const action = process.argv[3] || 'report';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      if (action === 'route') {
+        const result = lib.routeByCost({ type: process.argv[4] || 'coding' });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Cost route: ${result.selected_model} ($${result.estimated_cost})`));
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n💵 Cost Router: ${result.budget_profile} profile, $${result.total_cost} total\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 56: Deterministic Artifacts ──────────────────────────────────
+    if (subcommand === 'deterministic') {
+      const lib = require('./lib/deterministic-artifacts');
+      const action = process.argv[3] || 'normalize';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      if (action === 'verify') {
+        const file1 = process.argv[4];
+        const file2 = process.argv[5];
+        if (!file1 || !file2) { console.error(chalk.red('Usage: jumpstart-mode deterministic verify <file1> <file2>')); process.exit(1); }
+        const result = lib.verifyStability(file1, file2);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.identical ? chalk.green('✅ Files are identical') : chalk.yellow(`⚠️ ${result.similarity}% similar (${result.diff_lines} diff lines)`));
+        }
+      } else {
+        const result = lib.normalizeSpecs(root, { write: process.argv.includes('--write') });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📐 Normalized ${result.files} spec files (${result.modified} modified)\n`));
+        }
+      }
+      return;
+    }
+
+    // ── Feature 57: Agent Checkpoint ─────────────────────────────────────────
+    if (subcommand === 'agent-checkpoint') {
+      const lib = require('./lib/agent-checkpoint');
+      const action = process.argv[3] || 'list';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const stateFile = path.join(process.cwd(), '.jumpstart', 'state', 'agent-checkpoints.json');
+      if (action === 'save') {
+        const agent = process.argv[4] || 'cli';
+        const result = lib.saveCheckpoint({ agent, type: 'manual' }, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Checkpoint saved: ${result.checkpoint.id}`));
+        }
+      } else if (action === 'restore') {
+        const cpId = process.argv[4];
+        const result = lib.restoreCheckpoint(cpId, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`✅ Restored: ${result.checkpoint.id}`) : chalk.red(`❌ ${result.error}`));
+        }
+      } else if (action === 'clean') {
+        const result = lib.cleanCheckpoints({ stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.green(`✅ Cleaned ${result.removed} checkpoints, ${result.remaining} remaining`));
+        }
+      } else {
+        const result = lib.listCheckpoints({}, { stateFile });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n💾 Checkpoints (${result.total})`));
+          for (const c of result.checkpoints) console.log(`  ${c.id}: ${c.agent} ${c.phase || ''} (${c.saved_at})`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ── Feature 58: Tool Guardrails ──────────────────────────────────────────
+    if (subcommand === 'tool-guardrails') {
+      const lib = require('./lib/tool-guardrails');
+      const action = process.argv[3] || 'check';
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const operation = process.argv[4];
+      if (!operation) { console.error(chalk.red('Usage: jumpstart-mode tool-guardrails check <operation>')); process.exit(1); }
+      const result = lib.checkOperation(operation);
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(result.allowed ? chalk.green(`✅ Operation allowed (${result.risk_level})`) : chalk.red(`❌ Operation blocked (${result.risk_level})`));
+        for (const v of result.violations) console.log(`  ⚠️ ${v.description}`);
+      }
+      return;
+    }
+
+    // ── Feature 59: Root Cause Analysis ──────────────────────────────────────
+    if (subcommand === 'root-cause') {
+      const lib = require('./lib/root-cause-analysis');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const filePath = process.argv[4] || process.argv[3];
+      if (!filePath || filePath === 'analyze' || filePath === 'report') {
+        console.error(chalk.red('Usage: jumpstart-mode root-cause <output-file>'));
+        process.exit(1);
+      }
+      const result = lib.analyzeTestFile(filePath);
+      if (jsonMode) { io.writeResult(result); } else {
+        if (result.success) {
+          console.log(chalk.bold(`\n🔍 Root Cause Analysis: ${result.total_hypotheses} hypotheses`));
+          if (result.hypotheses.length > 0) {
+            console.log(`  Primary: ${result.hypotheses[0].category} — ${result.hypotheses[0].suggested_fix}`);
+          }
+          for (const a of (result.hypotheses || []).slice(0, 5)) console.log(`  ${a.category}: ${a.detail.substring(0, 80)}`);
+        } else { console.log(chalk.red(`❌ ${result.error}`)); }
+        console.log('');
+      }
+      return;
+    }
+
+    // ── Feature 60: Quality Graph ────────────────────────────────────────────
+    if (subcommand === 'quality-graph') {
+      const lib = require('./lib/quality-graph');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const result = lib.scanQuality(root);
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n📊 Code Quality Graph: ${result.total_files} files`));
+        console.log(`  Average score: ${result.summary.average_score}%`);
+        console.log(`  Critical hotspots: ${result.summary.critical_hotspots}  High risk: ${result.summary.high_risk}`);
+        if (result.hotspots.length > 0) {
+          console.log('  Top hotspots:');
+          for (const h of result.hotspots.slice(0, 5)) console.log(`    ${h.file}: ${h.overall_score}% (${h.total_lines} lines, depth=${h.max_nesting_depth})`);
+        }
+        console.log('');
+      }
+      return;
+    }
+
+    // ─── Item 61: Web Dashboard ──────────────────────────────────────────────
+    if (subcommand === 'web-dashboard') {
+      const lib = require('./lib/web-dashboard');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const action = process.argv[3] || 'data';
+      if (action === 'config') {
+        const result = lib.generateConfig(root, { port: parseInt(process.argv[4]) || undefined });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🖥️  Dashboard Configuration'));
+          console.log(`  Port: ${result.config.port}  Host: ${result.config.host}`);
+          console.log(`  Sections: ${result.config.sections.join(', ')}\n`);
+        }
+      } else if (action === 'status') {
+        const result = lib.getServerStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🖥️  Dashboard Status'));
+          console.log(`  Running: ${result.running}  Port: ${result.port}\n`);
+        }
+      } else {
+        const result = lib.gatherDashboardData(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🖥️  Dashboard Data'));
+          console.log(`  Phase: ${result.sections.phases.current_phase}  Artifacts: ${result.sections.artifacts.total}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 62: Role Views ─────────────────────────────────────────────────
+    if (subcommand === 'role-views') {
+      const lib = require('./lib/role-views');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const action = process.argv[3] || 'list';
+      if (action === 'list') {
+        const result = lib.listRoles();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n👥 Available Roles'));
+          for (const r of result.roles) console.log(`  ${r.id}: ${r.label} — focus: ${r.focus.join(', ')}`);
+          console.log('');
+        }
+      } else if (action === 'generate') {
+        const role = process.argv[4] || 'engineer';
+        const result = lib.generateView(root, role);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (!result.success) { console.log(chalk.red(`\n❌ ${result.error}\n`)); } else {
+            console.log(chalk.bold(`\n👤 ${result.view.label}`));
+            console.log(`  Focus: ${result.view.focus_areas.join(', ')}`);
+            console.log(`  Phase: ${result.view.sections.phase_status.current_phase}\n`);
+          }
+        }
+      }
+      return;
+    }
+
+    // ─── Item 63: Spec Comments ──────────────────────────────────────────────
+    if (subcommand === 'spec-comments') {
+      const lib = require('./lib/spec-comments');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'add') {
+        const artifact = process.argv[4]; const text = process.argv[5];
+        const result = lib.addComment(artifact, null, text);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Comment ${result.comment.id} added to ${artifact}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'resolve') {
+        const commentId = process.argv[4]; const resolution = process.argv[5];
+        const result = lib.resolveComment(commentId, resolution);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Comment ${commentId} resolved\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.listComments({ status: process.argv[4] });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n💬 Spec Comments (${result.total})`));
+          for (const c of result.comments) console.log(`  [${c.status}] ${c.id}: ${c.text.substring(0, 60)}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 64: Workshop Mode ──────────────────────────────────────────────
+    if (subcommand === 'workshop-mode') {
+      const lib = require('./lib/workshop-mode');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'status';
+      if (action === 'start') {
+        const name = process.argv[4] || 'Workshop';
+        const result = lib.startSession(name);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Workshop ${result.session.id} started: ${name}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.getSessionStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🎯 Workshop Sessions (${result.total_sessions})`));
+          for (const s of result.sessions) console.log(`  ${s.id}: ${s.name} [${s.status}] (${s.captures} captures)`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 65: Collaboration ──────────────────────────────────────────────
+    if (subcommand === 'collaboration') {
+      const lib = require('./lib/collaboration');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'status';
+      if (action === 'create') {
+        const name = process.argv[4] || 'Session';
+        const result = lib.createSession(name);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Collaboration ${result.session.id} created\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.getStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🤝 Collaboration Status`));
+          console.log(`  Active sessions: ${result.active_sessions}  Active locks: ${result.active_locks}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 66: Structured Elicitation ─────────────────────────────────────
+    if (subcommand === 'elicitation') {
+      const lib = require('./lib/structured-elicitation');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'start';
+      if (action === 'start') {
+        const domain = process.argv[4] || 'general';
+        const result = lib.startElicitation(domain);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.green(`\n✅ Elicitation ${result.session.id} started for domain: ${domain}`));
+            console.log(`  Questions: ${result.session.questions.length}\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'report') {
+        const sessionId = process.argv[4];
+        const result = lib.generateReport(sessionId);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n📋 Elicitation Report: ${result.completion_pct}% complete`));
+            console.log(`  Answered: ${result.answered}/${result.total_questions}\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 67: Enterprise Templates ───────────────────────────────────────
+    if (subcommand === 'enterprise-templates') {
+      const lib = require('./lib/enterprise-templates');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'list') {
+        const result = lib.listTemplates();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🏢 Enterprise Templates'));
+          for (const t of result.templates) console.log(`  ${t.id}: ${t.label} (${t.compliance_count} compliance, ${t.persona_count} personas)`);
+          console.log('');
+        }
+      } else if (action === 'get') {
+        const vertical = process.argv[4];
+        const result = lib.getTemplate(vertical);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🏢 ${result.template.label}`));
+            console.log(`  Compliance: ${result.template.compliance.join(', ')}`);
+            console.log(`  Personas: ${result.template.personas.join(', ')}\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'apply') {
+        const vertical = process.argv[4];
+        const result = lib.applyTemplate(process.cwd(), vertical);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Template ${result.applied.label} applied\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 68: Playback Summaries ─────────────────────────────────────────
+    if (subcommand === 'playback-summaries') {
+      const lib = require('./lib/playback-summaries');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'generate') {
+        const audience = process.argv[4] || 'executive';
+        const result = lib.generateSummary(process.cwd(), audience);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n📣 ${result.summary.label}`));
+            console.log(`  Tone: ${result.summary.tone}  Focus: ${result.summary.focus_areas.join(', ')}\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.listAudiences();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n📣 Available Audiences'));
+          for (const a of result.audiences) console.log(`  ${a.id}: ${a.label} (${a.tone})`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 69: Design System ──────────────────────────────────────────────
+    if (subcommand === 'design-system') {
+      const lib = require('./lib/design-system');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'check') {
+        const result = lib.checkCompliance();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🎨 Design System Compliance'));
+          console.log(`  Compliant: ${result.compliant}  Issues: ${result.issues.length}\n`);
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🎨 Design System Report'));
+          console.log(`  Components: ${result.components}  Level: ${result.accessibility_level}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 70: Diagram Studio ─────────────────────────────────────────────
+    if (subcommand === 'diagram-studio') {
+      const lib = require('./lib/diagram-studio');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'generate') {
+        const type = process.argv[4] || 'sequence';
+        const result = lib.generateDiagram(type);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) { console.log(chalk.bold(`\n📐 Diagram: ${type}`)); console.log(result.content + '\n'); }
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'validate') {
+        const file = process.argv[4];
+        if (file && fs.existsSync(file)) {
+          const content = fs.readFileSync(file, 'utf8');
+          const result = lib.validateDiagram(content);
+          if (jsonMode) { io.writeResult(result); } else {
+            console.log(chalk.bold(`\n📐 Diagram Validation: ${result.valid ? 'Valid' : 'Issues Found'}`));
+            for (const i of result.issues) console.log(`  [${i.type}] ${i.message}`);
+            console.log('');
+          }
+        } else console.log(chalk.red('\n❌ File path required for validate\n'));
+      } else {
+        const result = lib.listDiagramTypes();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n📐 Diagram Types'));
+          for (const t of result.types) console.log(`  ${t}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 71: Ambiguity Heatmap ──────────────────────────────────────────
+    if (subcommand === 'ambiguity-heatmap') {
+      const lib = require('./lib/ambiguity-heatmap');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'scan') {
+        const file = process.argv[4];
+        if (file) {
+          const result = lib.scanFile(file);
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.success) {
+              console.log(chalk.bold(`\n🔥 Ambiguity Scan: ${result.total_findings} findings`));
+              console.log(`  Vague terms: ${result.metrics.vague_terms}  Missing constraints: ${result.metrics.missing_constraints}  Density: ${result.metrics.ambiguity_density}%\n`);
+            } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+          }
+        } else console.log(chalk.red('\n❌ File path required for scan\n'));
+      } else {
+        const result = lib.generateHeatmap(process.cwd());
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔥 Ambiguity Heatmap: ${result.files_scanned} files`));
+          console.log(`  Total findings: ${result.overall.total_findings}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 72: Estimation Studio ──────────────────────────────────────────
+    if (subcommand === 'estimation-studio') {
+      const lib = require('./lib/estimation-studio');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'estimate') {
+        const name = process.argv[4]; const size = process.argv[5];
+        const result = lib.estimateFeature(name, size);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n📊 Estimate: ${name}`));
+            console.log(`  Size: ${result.estimate.tshirt_size}  Points: ${result.estimate.story_points}  Days: ${result.estimate.ideal_days}`);
+            console.log(`  ROM: $${result.estimate.rom_cost.min}–$${result.estimate.rom_cost.max}\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📊 Estimation Report: ${result.total_features} features`));
+          console.log(`  Total points: ${result.total_story_points}  Total days: ${result.total_ideal_days}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 73: Guided Handoff ─────────────────────────────────────────────
+    if (subcommand === 'guided-handoff') {
+      const lib = require('./lib/guided-handoff');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'generate') {
+        const type = process.argv[4] || 'product-to-engineering';
+        const result = lib.generateHandoff(type, process.cwd());
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n📦 Handoff: ${result.label}`));
+            console.log(`  Complete: ${result.complete}  Missing: ${result.missing_required.join(', ') || 'none'}\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.listHandoffTypes();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n📦 Handoff Types'));
+          for (const t of result.types) console.log(`  ${t.id}: ${t.label} (${t.required_count} required, ${t.optional_count} optional)`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 74: Transcript Ingestion ───────────────────────────────────────
+    if (subcommand === 'transcript-ingestion') {
+      const lib = require('./lib/transcript-ingestion');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'ingest') {
+        const file = process.argv[4];
+        if (file && fs.existsSync(file)) {
+          const text = fs.readFileSync(file, 'utf8');
+          const result = lib.ingestTranscript(text, { title: path.basename(file) });
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.success) {
+              console.log(chalk.green(`\n✅ Transcript ingested: ${result.transcript.id}`));
+              console.log(`  Actions: ${result.transcript.actions.length}  Decisions: ${result.transcript.decisions.length}\n`);
+            }
+          }
+        } else console.log(chalk.red('\n❌ File path required for ingest\n'));
+      } else {
+        const result = lib.listTranscripts();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🎙️  Transcripts (${result.total})`));
+          for (const t of result.transcripts) console.log(`  ${t.id}: ${t.title} (${t.actions} actions, ${t.decisions} decisions)`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 75: Chat Integration ───────────────────────────────────────────
+    if (subcommand === 'chat-integration') {
+      const lib = require('./lib/chat-integration');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'status';
+      if (action === 'configure') {
+        const platform = process.argv[4] || 'slack';
+        const result = lib.configure(platform);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ ${platform} integration configured: ${result.configuration.id}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'notify') {
+        const eventType = process.argv[4]; const message = process.argv[5];
+        const result = lib.queueNotification(eventType, message);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Notification queued: ${result.notification.id}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.getStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n💬 Chat Integration Status'));
+          console.log(`  Configurations: ${result.configurations}  Active: ${result.active}  Queued: ${result.notifications_queued}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 76: Context Onboarding ─────────────────────────────────────────
+    if (subcommand === 'context-onboarding') {
+      const lib = require('./lib/context-onboarding');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const role = process.argv[3] || 'engineer';
+      const result = lib.generateOnboarding(process.cwd(), { role });
+      if (jsonMode) { io.writeResult(result); } else {
+        if (result.success) {
+          const ob = result.onboarding;
+          console.log(chalk.bold(`\n🎓 Onboarding Package (${ob.role})`));
+          console.log(`  Decisions: ${ob.sections.decisions.total}  Risks: ${ob.sections.risks.total}`);
+          console.log(`  Specs: ${ob.sections.specs.total}  Phase: ${ob.sections.project_status.current_phase}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 77: Promptless Mode ────────────────────────────────────────────
+    if (subcommand === 'promptless-mode') {
+      const lib = require('./lib/promptless-mode');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'status';
+      if (action === 'start') {
+        const wizard = process.argv[4] || 'new-project';
+        const result = lib.startWizard(wizard);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.green(`\n✅ Wizard started: ${result.session.id}`));
+            if (result.next_step) console.log(`  Next: ${result.next_step.prompt}`);
+            console.log('');
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.getWizardStatus();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🧙 Promptless Mode'));
+          console.log(`  Available wizards: ${result.available_wizards.join(', ')}`);
+          for (const s of result.sessions) console.log(`  ${s.id}: ${s.wizard} [${s.status}] (${s.progress})`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 78: Artifact Comparison ────────────────────────────────────────
+    if (subcommand === 'artifact-comparison') {
+      const lib = require('./lib/artifact-comparison');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'history';
+      if (action === 'compare') {
+        const fileA = process.argv[4]; const fileB = process.argv[5];
+        if (fileA && fileB) {
+          const result = lib.compareFiles(fileA, fileB);
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.success) {
+              console.log(chalk.bold(`\n📄 Artifact Comparison: ${result.total_changes} changes`));
+              console.log(`  Lines: ${result.lines_before} → ${result.lines_after} (${result.line_diff >= 0 ? '+' : ''}${result.line_diff})`);
+              for (const c of result.changes) console.log(`  [${c.type}] ${c.summary}`);
+              console.log('');
+            } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+          }
+        } else console.log(chalk.red('\n❌ Two file paths required for compare\n'));
+      } else {
+        const artifact = process.argv[4] || 'prd.md';
+        const result = lib.getArtifactHistory(process.cwd(), artifact);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📄 Artifact History: ${result.artifact}`));
+          console.log(`  Versions: ${result.versions}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 79: Workstream Ownership ───────────────────────────────────────
+    if (subcommand === 'workstream-ownership') {
+      const lib = require('./lib/workstream-ownership');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'define') {
+        const name = process.argv[4];
+        const result = lib.defineWorkstream(name, { team: process.argv[5] });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Workstream ${result.workstream.id} defined: ${name}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔗 Workstream Report: ${result.total_workstreams} workstreams, ${result.total_dependencies} dependencies\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 80: Persona Packs ──────────────────────────────────────────────
+    if (subcommand === 'persona-packs') {
+      const lib = require('./lib/persona-packs');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'get') {
+        const id = process.argv[4];
+        const result = lib.getPersona(id);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n👤 ${result.persona.label}`));
+            console.log(`  Focus: ${result.persona.focus.join(', ')}`);
+            console.log(`  Tools: ${result.persona.tools.join(', ')}\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'apply') {
+        const id = process.argv[4];
+        const result = lib.applyPersona(id);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Persona ${result.label} applied\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.listPersonas();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n👤 Persona Packs'));
+          for (const p of result.personas) console.log(`  ${p.id}: ${p.label} (${p.focus_count} focus, ${p.tools_count} tools)`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 81: Knowledge Graph ────────────────────────────────────────────
+    if (subcommand === 'knowledge-graph') {
+      const lib = require('./lib/knowledge-graph');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'add') {
+        const name = process.argv[4]; const type = process.argv[5];
+        const result = lib.addNode(name, type);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Node ${result.node.id} added: ${name} (${type})\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'query') {
+        const search = process.argv[4];
+        const result = lib.queryGraph({ search });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🧠 Knowledge Graph: ${result.nodes} nodes, ${result.edges} edges`));
+          for (const n of result.results) console.log(`  ${n.id}: ${n.name} (${n.type})`);
+          console.log('');
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🧠 Knowledge Graph Report: ${result.total_nodes} nodes, ${result.total_edges} edges\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 82: Pattern Library ────────────────────────────────────────────
+    if (subcommand === 'pattern-library') {
+      const lib = require('./lib/pattern-library');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'register') {
+        const name = process.argv[4]; const category = process.argv[5];
+        const result = lib.registerPattern(name, category);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Pattern ${result.pattern.id} registered: ${name}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'search') {
+        const query = process.argv[4];
+        const result = lib.searchPatterns(query);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📚 Pattern Search: ${result.total} results`));
+          for (const p of result.patterns) console.log(`  ${p.id}: ${p.name} (${p.category})`);
+          console.log('');
+        }
+      } else {
+        const result = lib.listPatterns();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📚 Pattern Library: ${result.total} patterns`));
+          for (const p of result.patterns) console.log(`  ${p.id}: ${p.name} [${p.category}]`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 83: Domain Ontology ────────────────────────────────────────────
+    if (subcommand === 'domain-ontology') {
+      const lib = require('./lib/domain-ontology');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'define') {
+        const domain = process.argv[4]; const name = process.argv[5]; const type = process.argv[6];
+        const result = lib.defineElement(domain, name, type);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Element ${result.element.id} defined: ${name} (${type})\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'query') {
+        const domain = process.argv[4];
+        const result = lib.queryOntology(domain);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🏷️  Ontology: ${result.domain} (${result.total} elements)\n`));
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🏷️  Domain Ontology Report: ${result.total_domains} domains\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 84: Data Contracts ─────────────────────────────────────────────
+    if (subcommand === 'data-contracts') {
+      const lib = require('./lib/data-contracts');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'register') {
+        const name = process.argv[4];
+        const result = lib.registerContract(name, { field1: 'string' });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Contract ${result.contract.id} registered: ${name}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📜 Data Contracts: ${result.total_contracts} contracts, ${result.total_lineage} lineage entries\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 85: Event Modeling ─────────────────────────────────────────────
+    if (subcommand === 'event-modeling') {
+      const lib = require('./lib/event-modeling');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'define') {
+        const name = process.argv[4]; const type = process.argv[5] || 'topic';
+        if (type === 'topic') {
+          const result = lib.defineTopic(name);
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.success) console.log(chalk.green(`\n✅ Topic ${result.topic.id} defined: ${name}\n`));
+            else console.log(chalk.red(`\n❌ ${result.error}\n`));
+          }
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📡 Event Model: ${result.total_topics} topics, ${result.total_events} events, ${result.total_sagas} sagas\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 86: Platform Engineering ───────────────────────────────────────
+    if (subcommand === 'platform-engineering') {
+      const lib = require('./lib/platform-engineering');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'register') {
+        const name = process.argv[4]; const type = process.argv[5] || 'service';
+        const result = lib.registerTemplate(name, type);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Template ${result.template.id} registered: ${name}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'list') {
+        const result = lib.listTemplates();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🏗️  Platform Templates: ${result.total}`));
+          for (const t of result.templates) console.log(`  ${t.id}: ${t.name} (${t.type})`);
+          console.log('');
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🏗️  Platform Report: ${result.total_templates} templates, ${result.total_instances} instances\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 90: AI Evaluation ──────────────────────────────────────────────
+    if (subcommand === 'ai-evaluation') {
+      const lib = require('./lib/ai-evaluation');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'evaluate') {
+        const name = process.argv[4];
+        const result = lib.evaluate(name, { groundedness: 80, hallucination: 90, safety: 85 });
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🤖 AI Evaluation: ${name}`));
+            console.log(`  Overall: ${result.evaluation.overall}%\n`);
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🤖 AI Evaluation Report: ${result.total_evaluations} evaluations\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 91: Prompt Governance ──────────────────────────────────────────
+    if (subcommand === 'prompt-governance') {
+      const lib = require('./lib/prompt-governance');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'register') {
+        const name = process.argv[4]; const type = process.argv[5] || 'prompt';
+        const result = lib.registerAsset(name, type, 'content');
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Asset ${result.asset.id} registered: ${name}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'approve') {
+        const assetId = process.argv[4]; const version = process.argv[5] || '1.0.0';
+        const result = lib.approveVersion(assetId, version);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Version ${version} approved\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.listAssets();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📋 Prompt Governance: ${result.total} assets`));
+          for (const a of result.assets) console.log(`  ${a.id}: ${a.name} [${a.type}] v${a.current_version}`);
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 94: SRE Integration ────────────────────────────────────────────
+    if (subcommand === 'sre-integration') {
+      const lib = require('./lib/sre-integration');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'generate') {
+        const type = process.argv[4] || 'monitor';
+        if (type === 'monitor') {
+          const name = process.argv[5] || 'default-monitor';
+          const result = lib.generateMonitor(name, 'uptime');
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.success) console.log(chalk.green(`\n✅ Monitor ${result.monitor.id} generated: ${name}\n`));
+            else console.log(chalk.red(`\n❌ ${result.error}\n`));
+          }
+        } else if (type === 'alert') {
+          const name = process.argv[5] || 'default-alert';
+          const result = lib.generateAlert(name, 'warning');
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.success) console.log(chalk.green(`\n✅ Alert ${result.alert.id} generated: ${name}\n`));
+            else console.log(chalk.red(`\n❌ ${result.error}\n`));
+          }
+        } else if (type === 'runbook') {
+          const name = process.argv[5] || 'default-runbook';
+          const result = lib.generateRunbook(name, ['Check status', 'Restart service', 'Verify recovery']);
+          if (jsonMode) { io.writeResult(result); } else {
+            if (result.success) console.log(chalk.green(`\n✅ Runbook ${result.runbook.id} generated: ${name}\n`));
+            else console.log(chalk.red(`\n❌ ${result.error}\n`));
+          }
+        }
+      } else {
+        const result = lib.generateReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔧 SRE Report: ${result.total_monitors} monitors, ${result.total_alerts} alerts, ${result.total_runbooks} runbooks\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 95: Telemetry Feedback ─────────────────────────────────────────
+    if (subcommand === 'telemetry-feedback') {
+      const lib = require('./lib/telemetry-feedback');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'report';
+      if (action === 'ingest') {
+        const name = process.argv[4]; const type = process.argv[5]; const value = parseFloat(process.argv[6]);
+        const result = lib.ingestMetric(name, type, value);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) console.log(chalk.green(`\n✅ Metric ingested: ${result.metric.id}\n`));
+          else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'analyze') {
+        const result = lib.analyzeMetrics();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📈 Telemetry Analysis: ${result.total_metrics} metrics\n`));
+        }
+      } else {
+        const result = lib.generateFeedbackReport();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📈 Telemetry Report: ${result.total_metrics} metrics`));
+          if (result.recommendations.length > 0) {
+            for (const r of result.recommendations) console.log(`  ⚠️  ${r}`);
+          }
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 96: Enterprise Search ──────────────────────────────────────────
+    if (subcommand === 'enterprise-search') {
+      const lib = require('./lib/enterprise-search');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const action = process.argv[3] || 'index';
+      if (action === 'search') {
+        const query = process.argv[4];
+        const result = lib.searchProject(root, query);
+        if (jsonMode) { io.writeResult(result); } else {
+          if (result.success) {
+            console.log(chalk.bold(`\n🔍 Search: "${query}" — ${result.total_results} results`));
+            for (const r of result.results) console.log(`  [${r.type}] ${r.path} (${r.matches} matches)`);
+            console.log('');
+          } else console.log(chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else {
+        const result = lib.indexProject(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔍 Enterprise Search Index: ${result.total_entries} entries\n`));
+        }
+      }
+      return;
+    }
+
+    // ─── Item 40: Revert / Rollback Workflows ────────────────────────────────
+    if (subcommand === 'revert') {
+      const { revertArtifact } = await import('./lib/revert.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const artifactPath = process.argv[3];
+      if (!artifactPath || artifactPath.startsWith('--')) {
+        console.error(chalk.red('Usage: jumpstart-mode revert <artifact-path> [--reason "..."]'));
+        process.exit(1);
+      }
+      const reasonIdx = process.argv.indexOf('--reason');
+      const reason = reasonIdx > -1 ? process.argv[reasonIdx + 1] : undefined;
+      const result = revertArtifact({ artifact: artifactPath, reason });
+      if (jsonMode) { io.writeResult(result); } else {
+        if (result.success) {
+          console.log(chalk.green(`\n✅ Reverted: ${artifactPath}`));
+          console.log(`  Archived to: ${result.archived_to}`);
+          console.log(`  Restored from: ${result.restored_from || 'none (archive only)'}`);
+          console.log(`  Reason: ${result.reason}\n`);
+        } else { console.log(chalk.red(`\n❌ ${result.error}\n`)); }
+      }
+      return;
+    }
+
+    // ─── Item 51: ADR Index ──────────────────────────────────────────────────
+    if (subcommand === 'adr') {
+      const { buildIndex, searchIndex } = await import('./lib/adr-index.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.cwd();
+      const action = process.argv[3] || 'build';
+      if (action === 'search') {
+        const query = process.argv[4] || '';
+        const tag = process.argv.includes('--tag') ? process.argv[process.argv.indexOf('--tag') + 1] : undefined;
+        const index = buildIndex(root);
+        const result = searchIndex(index, query, { tag });
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📋 ADR Search: "${query}" — ${result.total} results`));
+          for (const r of result.results) console.log(`  ${r.id}: ${r.title} [${r.status}]`);
+          console.log('');
+        }
+      } else {
+        const result = buildIndex(root);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n📋 ADR Index: ${result.indexed} records indexed`));
+          console.log(`  Index path: ${result.index_path}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 33: Complexity Calculator ──────────────────────────────────────
+    if (subcommand === 'complexity') {
+      const { calculateComplexity } = await import('./lib/complexity.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const desc = process.argv[3] && !process.argv[3].startsWith('--') ? process.argv[3] : '';
+      const result = calculateComplexity({ description: desc, root: process.cwd() });
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n📊 Complexity Assessment`));
+        console.log(`  Recommended depth: ${result.recommended_depth}`);
+        console.log(`  Score: ${result.score}`);
+        console.log(`  Reasoning: ${result.reasoning}\n`);
+      }
+      return;
+    }
+
+    // ─── Item 47: Cross-Reference Validation ────────────────────────────────
+    if (subcommand === 'crossref') {
+      const { validateCrossRefs } = await import('./lib/crossref.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const specsDir = process.argv[3] && !process.argv[3].startsWith('--') ? process.argv[3] : 'specs';
+      const root = process.cwd();
+      const result = validateCrossRefs(specsDir, root);
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🔗 Cross-Reference Validation`));
+        console.log(`  Files scanned: ${result.files_scanned}  Total links: ${result.total_links}`);
+        console.log(`  Valid: ${result.valid_links}  Broken: ${result.broken_links.length}`);
+        console.log(`  Score: ${result.score}%  ${result.pass ? chalk.green('PASS') : chalk.red('FAIL')}`);
+        if (result.broken_links.length > 0) {
+          console.log('  Broken links:');
+          for (const b of result.broken_links.slice(0, 10)) console.log(`    ${b.file}:${b.line} → ${b.target}`);
+        }
+        console.log('');
+      }
+      return;
+    }
+
+    // ─── Item 76: Interactive Init ───────────────────────────────────────────
+    if (subcommand === 'init') {
+      const { generateInitConfig } = await import('./lib/init.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const skillLevel = process.argv[3] && !process.argv[3].startsWith('--') ? process.argv[3] : 'intermediate';
+      const projectType = process.argv.includes('--type') ? process.argv[process.argv.indexOf('--type') + 1] : 'greenfield';
+      const result = generateInitConfig({ skill_level: skillLevel, project_type: projectType });
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold(`\n🎯 Init Configuration (${result.skill_level})`));
+        console.log(`  Explanation depth: ${result.explanation_depth}`);
+        console.log(`  Project type: ${result.project_type}`);
+        console.log('  Recommendations:');
+        for (const r of result.recommendations) console.log(`    • ${r}`);
+        console.log('');
+      }
+      return;
+    }
+
+    // ─── Item 45: File Locking ──────────────────────────────────────────────
+    if (subcommand === 'lock') {
+      const { acquireLock, releaseLock, lockStatus, listLocks } = await import('./lib/locks.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'list';
+      if (action === 'acquire') {
+        const file = process.argv[4];
+        const agent = process.argv[5] || 'cli';
+        if (!file) { console.error(chalk.red('Usage: jumpstart-mode lock acquire <file> [agent]')); process.exit(1); }
+        const result = acquireLock(file, agent);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`\n✅ Lock acquired: ${file} by ${agent}\n`) : chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'release') {
+        const file = process.argv[4];
+        const agent = process.argv[5] || 'cli';
+        if (!file) { console.error(chalk.red('Usage: jumpstart-mode lock release <file> [agent]')); process.exit(1); }
+        const result = releaseLock(file, agent);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.success ? chalk.green(`\n✅ Lock released: ${file}\n`) : chalk.red(`\n❌ ${result.error}\n`));
+        }
+      } else if (action === 'status') {
+        const file = process.argv[4];
+        if (!file) { console.error(chalk.red('Usage: jumpstart-mode lock status <file>')); process.exit(1); }
+        const result = lockStatus(file);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold('\n🔒 Lock Status'));
+          console.log(`  File: ${file}`);
+          console.log(`  Locked: ${result.locked}`);
+          if (result.lock) console.log(`  By: ${result.lock.agent}  Since: ${result.lock.acquired_at}`);
+          console.log('');
+        }
+      } else {
+        const result = listLocks();
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🔒 Active Locks (${result.total})`));
+          for (const l of result.locks) console.log(`  ${l.file}: ${l.agent} (${l.acquired_at})`);
+          if (result.total === 0) console.log('  No active locks');
+          console.log('');
+        }
+      }
+      return;
+    }
+
+    // ─── Item 60: Timestamp Utilities ────────────────────────────────────────
+    if (subcommand === 'timestamp') {
+      const { now, validate: validateTs, audit: auditTs } = await import('./lib/timestamps.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const action = process.argv[3] || 'now';
+      if (action === 'validate') {
+        const value = process.argv[4];
+        if (!value) { console.error(chalk.red('Usage: jumpstart-mode timestamp validate <timestamp>')); process.exit(1); }
+        const result = validateTs(value);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(result.valid ? chalk.green(`\n✅ Valid: ${value}\n`) : chalk.red(`\n❌ Invalid: ${result.error}\n`));
+        }
+      } else if (action === 'audit') {
+        const file = process.argv[4];
+        if (!file) { console.error(chalk.red('Usage: jumpstart-mode timestamp audit <file>')); process.exit(1); }
+        const result = auditTs(file);
+        if (jsonMode) { io.writeResult(result); } else {
+          console.log(chalk.bold(`\n🕐 Timestamp Audit: ${file}`));
+          console.log(`  Entries: ${result.entries}  Valid: ${result.valid}  Invalid: ${result.invalid.length}`);
+          if (result.invalid.length > 0) {
+            for (const inv of result.invalid.slice(0, 5)) console.log(`    Line ${inv.line}: ${inv.value}`);
+          }
+          console.log('');
+        }
+      } else {
+        const ts = now();
+        if (jsonMode) { io.writeResult({ timestamp: ts }); } else {
+          console.log(`\n🕐 ${ts}\n`);
+        }
+      }
+      return;
+    }
+
+    // ─── Item 49: Project Scanner ────────────────────────────────────────────
+    if (subcommand === 'scan') {
+      const { scan: scanProject } = await import('./lib/scanner.js');
+      const jsonMode = process.argv.includes('--json');
+      const io = require('./lib/io');
+      const root = process.argv[3] && !process.argv[3].startsWith('--') ? process.argv[3] : process.cwd();
+      const result = scanProject({ root });
+      if (jsonMode) { io.writeResult(result); } else {
+        console.log(chalk.bold('\n🔍 Project Scan Results'));
+        console.log(`  Files: ${result.stats.files}  Directories: ${result.stats.directories}`);
+        if (result.stack) {
+          const s = result.stack;
+          if (s.language) console.log(`  Language: ${Array.isArray(s.language) ? s.language.join(', ') : s.language}`);
+          if (s.runtime) console.log(`  Runtime: ${s.runtime}`);
+          if (s.framework) console.log(`  Framework: ${Array.isArray(s.framework) ? s.framework.join(', ') : s.framework}`);
+        }
+        if (result.risks && result.risks.length > 0) {
+          console.log('  Risks:');
+          for (const r of result.risks.slice(0, 5)) console.log(`    ⚠ ${r}`);
+        }
+        console.log('');
+      }
+      return;
+    }
+
     let config = parseArgs();
 
     if (config.help) {