@polymorphism-tech/morph-spec 4.2.0 → 4.3.0

package/src/commands/templates/template-render.js

@@ -3,11 +3,90 @@
  */
 
 import { writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
+import { dirname, join } from 'path';
 import chalk from 'chalk';
 import { logger } from '../../utils/logger.js';
 import { getTemplateById, resolveTemplatePathById } from '../../core/templates/template-registry.js';
 import { renderTemplate } from '../../core/templates/template-renderer.js';
+import { renderHOP, listAvailableHOPs } from '../../lib/hops/hop-composer.js';
+
+/**
+ * Render HOP (Higher-Order Prompt) template command
+ */
+export async function hopRenderCommand(hopId, outputPath, variablesJson, options) {
+  logger.header(`Rendering HOP: ${hopId}`);
+  logger.blank();
+
+  try {
+    // Parse variables
+    let variables = {};
+    try {
+      variables = JSON.parse(variablesJson || '{}');
+    } catch (error) {
+      logger.error('Invalid JSON in variables argument');
+      logger.dim(`  ${error.message}`);
+      process.exit(1);
+    }
+
+    // Add defaults
+    variables.DATE = variables.DATE || new Date().toISOString().split('T')[0];
+    variables.YEAR = variables.YEAR || new Date().getFullYear().toString();
+    variables.TIMESTAMP = variables.TIMESTAMP || new Date().toISOString();
+
+    // Render via hop-composer
+    const frameworkRoot = join(process.cwd(), 'framework');
+    const rendered = renderHOP(hopId, variables, { frameworkRoot });
+
+    if (options?.dryRun || !outputPath) {
+      logger.info(chalk.cyan('📋 HOP Preview:'));
+      logger.blank();
+      console.log(rendered);
+      logger.blank();
+      if (outputPath) logger.dim(`Would be written to: ${outputPath}`);
+    } else {
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, rendered, 'utf-8');
+      logger.success(`✅ HOP rendered: ${chalk.cyan(outputPath)}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to render HOP: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * List available HOPs
+ */
+export async function hopListCommand(options) {
+  logger.header('Available HOPs (Higher-Order Prompts)');
+  logger.blank();
+
+  const frameworkRoot = join(process.cwd(), 'framework');
+  const hops = listAvailableHOPs(frameworkRoot);
+
+  if (hops.length === 0) {
+    logger.warn('No HOPs found in framework/templates/meta-prompts/');
+    return;
+  }
+
+  const byType = {};
+  for (const hop of hops) {
+    const type = hop.type || 'other';
+    if (!byType[type]) byType[type] = [];
+    byType[type].push(hop);
+  }
+
+  for (const [type, list] of Object.entries(byType)) {
+    console.log(chalk.cyan(`\n  ${type.toUpperCase()}`));
+    for (const hop of list) {
+      console.log(`    ${chalk.white(hop.id.padEnd(30))} ${chalk.gray(hop.description || hop.path)}`);
+    }
+  }
+
+  logger.blank();
+  logger.dim(`Total: ${hops.length} HOPs`);
+  logger.dim(`Render: morph-spec hop render <hop-id> <output-file> '<variables-json>'`);
+}
 
 /**
  * Render template command

package/src/commands/threads/thread-template.js

@@ -0,0 +1,103 @@
+/**
+ * Thread Template CLI command — Thread type management
+ *
+ * Usage:
+ *   morph-spec thread-template list
+ *   morph-spec thread-template use <type> --feature=<feature>
+ */
+
+import chalk from 'chalk';
+import { THREAD_TYPES } from '../../lib/threads/thread-manager.js';
+
+const THREAD_TYPE_INFO = {
+  [THREAD_TYPES.BASE]: {
+    name: 'B-Thread (Base)',
+    description: 'Standard single-agent thread. Sequential execution, all approval gates required.',
+    useCase: 'Default for simple and medium features',
+    phases: 'All standard phases',
+    approvalGates: 'Manual (all)',
+    maxConcurrent: 1
+  },
+  [THREAD_TYPES.PARALLEL]: {
+    name: 'P-Thread (Parallel)',
+    description: 'Multiple agents run simultaneously on different feature domains.',
+    useCase: 'Full-stack features with independent backend/frontend/infra work',
+    phases: 'All phases (parallel IMPLEMENT)',
+    approvalGates: 'Manual (all)',
+    maxConcurrent: 5
+  },
+  [THREAD_TYPES.FUSION]: {
+    name: 'F-Thread (Fusion)',
+    description: 'N agents independently generate solutions; best-of-N result is selected.',
+    useCase: 'High-uncertainty decisions, critical architecture choices, prototype evaluation',
+    phases: 'DESIGN → parallel IMPLEMENT → AGGREGATE → SYNC',
+    approvalGates: 'Manual select (or auto best-of-n)',
+    maxConcurrent: 3
+  },
+  [THREAD_TYPES.LONG_RUNNING]: {
+    name: 'L-Thread (Long-Running)',
+    description: 'Autonomous agent with stop hooks every 30 minutes for validation.',
+    useCase: 'Large scope features (>10 files), autonomous implementation without interruption',
+    phases: 'IMPLEMENT (continuous) with periodic validation',
+    approvalGates: 'Auto (stop hooks validate)',
+    maxConcurrent: 1
+  },
+  [THREAD_TYPES.ZERO_TOUCH]: {
+    name: 'Z-Thread (Zero-Touch)',
+    description: 'Fully autonomous execution. Auto-approves all gates, auto-commits on success.',
+    useCase: 'Maximum-trust features with >95% checkpoint pass rate',
+    phases: 'All phases (auto-approved)',
+    approvalGates: 'Auto (trust-based)',
+    maxConcurrent: 1
+  }
+};
+
+export async function threadTemplateListCommand(options) {
+  console.log(chalk.cyan('\n  Thread Types (v3.0)\n'));
+  console.log('  ' + '─'.repeat(70));
+
+  for (const [type, info] of Object.entries(THREAD_TYPE_INFO)) {
+    console.log(`\n  ${chalk.bold(info.name)}`);
+    console.log(`  ${info.description}`);
+    console.log(`  ${chalk.gray('Use case:')} ${info.useCase}`);
+    console.log(`  ${chalk.gray('Phases:')} ${info.phases}`);
+    console.log(`  ${chalk.gray('Gates:')} ${info.approvalGates}`);
+    console.log(`  ${chalk.gray('Max concurrent:')} ${info.maxConcurrent}`);
+  }
+
+  console.log('\n  ' + '─'.repeat(70));
+  console.log(chalk.gray('\n  Set thread type: morph-spec thread-template use <type> --feature=<feature>\n'));
+}
+
+export async function threadTemplateUseCommand(type, options) {
+  if (!options.feature) {
+    console.error(chalk.red('--feature is required'));
+    process.exit(1);
+  }
+
+  if (!THREAD_TYPE_INFO[type]) {
+    console.error(chalk.red(`Unknown thread type: ${type}`));
+    console.error(chalk.gray(`Valid types: ${Object.keys(THREAD_TYPE_INFO).join(', ')}`));
+    process.exit(1);
+  }
+
+  const info = THREAD_TYPE_INFO[type];
+
+  // Special checks
+  if (type === THREAD_TYPES.ZERO_TOUCH) {
+    console.log(chalk.yellow('\n  ⚠ Z-Thread requires maximum trust level (>95% checkpoint pass rate)'));
+    console.log(chalk.gray('  Check trust: morph-spec trust status\n'));
+  }
+
+  // Update feature state with thread type
+  try {
+    const { updateFeature } = await import('../../core/state/state-manager.js');
+    await updateFeature(options.feature, 'threadType', type);
+    console.log(chalk.green(`\n  ✓ Thread type set: ${type} for feature: ${options.feature}`));
+    console.log(`  ${info.name}: ${info.description}`);
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`  Error updating state: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/threads/threads.js

@@ -0,0 +1,261 @@
+/**
+ * Threads CLI command — Thread lifecycle management
+ *
+ * Usage:
+ *   morph-spec threads list [--feature=<f>] [--status=<s>]
+ *   morph-spec threads status <id>
+ *   morph-spec threads kill <id>
+ *   morph-spec threads analytics [--feature=<f>]
+ *   morph-spec threads wait-all <feature>
+ *   morph-spec threads wait-any <feature>
+ */
+
+import chalk from 'chalk';
+import {
+  listThreads, getThread, killThread, getThreadAnalytics,
+  THREAD_STATUS, THREAD_TYPES
+} from '../../lib/threads/thread-manager.js';
+import { generateAsciiChart, generateTimelineChart } from '../../lib/analytics/analytics-engine.js';
+
+const STATUS_COLORS = {
+  [THREAD_STATUS.PENDING]: chalk.yellow,
+  [THREAD_STATUS.RUNNING]: chalk.cyan,
+  [THREAD_STATUS.COMPLETED]: chalk.green,
+  [THREAD_STATUS.FAILED]: chalk.red,
+  [THREAD_STATUS.KILLED]: chalk.gray
+};
+
+const TYPE_ICONS = {
+  [THREAD_TYPES.BASE]: '◆',
+  [THREAD_TYPES.PARALLEL]: '⫸',
+  [THREAD_TYPES.FUSION]: '⊕',
+  [THREAD_TYPES.LONG_RUNNING]: '∞',
+  [THREAD_TYPES.ZERO_TOUCH]: '⚡'
+};
+
+function formatDuration(seconds) {
+  if (!seconds) return '—';
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+}
+
+/**
+ * List threads
+ */
+export async function threadsListCommand(options) {
+  try {
+    const threads = listThreads({
+      feature: options.feature,
+      status: options.status,
+      type: options.type
+    });
+
+    if (threads.length === 0) {
+      console.log(chalk.gray('No threads found.'));
+      return;
+    }
+
+    console.log(chalk.cyan(`\n  Threads (${threads.length})\n`));
+    console.log(
+      '  ' + 'ID'.padEnd(10) + ' ' +
+      'Type'.padEnd(14) + ' ' +
+      'Status'.padEnd(12) + ' ' +
+      'Feature'.padEnd(20) + ' ' +
+      'Agent'.padEnd(20) + ' ' +
+      'Duration'
+    );
+    console.log('  ' + '─'.repeat(90));
+
+    for (const t of threads) {
+      const icon = TYPE_ICONS[t.type] || '◆';
+      const colorFn = STATUS_COLORS[t.status] || chalk.white;
+      const shortId = t.id.substring(0, 8);
+
+      console.log(
+        '  ' +
+        chalk.gray(shortId) + ' ' +
+        `${icon} ${t.type}`.padEnd(14) + ' ' +
+        colorFn(t.status.padEnd(12)) + ' ' +
+        (t.feature || '—').padEnd(20) + ' ' +
+        (t.agent || '—').padEnd(20) + ' ' +
+        formatDuration(t.duration)
+      );
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Show thread status detail
+ */
+export async function threadsStatusCommand(id) {
+  try {
+    const thread = getThread(id);
+    if (!thread) {
+      console.error(chalk.red(`Thread not found: ${id}`));
+      process.exit(1);
+    }
+
+    const colorFn = STATUS_COLORS[thread.status] || chalk.white;
+    const icon = TYPE_ICONS[thread.type] || '◆';
+
+    console.log(chalk.cyan('\n  Thread Detail\n'));
+    console.log(`  ID:       ${chalk.gray(thread.id)}`);
+    console.log(`  Type:     ${icon} ${thread.type}`);
+    console.log(`  Status:   ${colorFn(thread.status)}`);
+    console.log(`  Feature:  ${thread.feature || '—'}`);
+    console.log(`  Agent:    ${thread.agent || '—'}`);
+    console.log(`  Mission:  ${thread.mission || '—'}`);
+    console.log(`  Created:  ${thread.createdAt}`);
+    console.log(`  Started:  ${thread.startedAt || '—'}`);
+    console.log(`  Ended:    ${thread.completedAt || '—'}`);
+    console.log(`  Duration: ${formatDuration(thread.duration)}`);
+
+    if (thread.metrics) {
+      console.log('\n  Metrics:');
+      console.log(`    Tool calls:     ${thread.metrics.toolCalls || 0}`);
+      console.log(`    Tokens used:    ${(thread.metrics.tokensUsed || 0).toLocaleString()}`);
+      console.log(`    Checkpoints OK: ${thread.metrics.checkpointsPassed || 0}`);
+      console.log(`    Checkpoints KO: ${thread.metrics.checkpointsFailed || 0}`);
+    }
+
+    if (thread.events?.length > 0) {
+      console.log(`\n  Recent events (${thread.events.length}):`);
+      thread.events.slice(-5).forEach(e => {
+        console.log(`    ${chalk.gray(e.timestamp)} ${e.type}`);
+      });
+    }
+
+    if (thread.failureReason) {
+      console.log(`\n  ${chalk.red('Failure:')} ${thread.failureReason}`);
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Kill a thread
+ */
+export async function threadsKillCommand(id) {
+  try {
+    const thread = killThread(id);
+    console.log(chalk.yellow(`✓ Thread ${id.substring(0, 8)} killed.`));
+    console.log(`  Status: ${thread.status} | Duration: ${formatDuration(thread.duration)}`);
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Show threads analytics dashboard
+ */
+export async function threadsAnalyticsCommand(options) {
+  try {
+    const feature = options.feature;
+    if (!feature) {
+      console.error(chalk.red('--feature is required for analytics'));
+      process.exit(1);
+    }
+
+    const analytics = getThreadAnalytics(feature);
+
+    console.log(chalk.cyan(`\n  Thread Analytics — ${feature}\n`));
+    console.log(`  Total threads:   ${analytics.total}`);
+    console.log(`  By status:`);
+    for (const [status, count] of Object.entries(analytics.byStatus)) {
+      const colorFn = STATUS_COLORS[status] || chalk.white;
+      console.log(`    ${colorFn(status.padEnd(12))} ${count}`);
+    }
+
+    console.log('\n  By type:');
+    for (const [type, count] of Object.entries(analytics.byType)) {
+      const icon = TYPE_ICONS[type] || '◆';
+      console.log(`    ${icon} ${type.padEnd(14)} ${count}`);
+    }
+
+    console.log(`\n  Avg duration:    ${formatDuration(analytics.avgDuration)}`);
+    console.log(`  Total tool calls: ${analytics.totalToolCalls}`);
+    console.log(`  Checkpoint pass rate: ${Math.round(analytics.checkpointPassRate * 100)}%`);
+
+    if (analytics.total > 0) {
+      const statusChart = generateAsciiChart(analytics.byStatus, { title: 'Threads by Status' });
+      console.log('\n' + statusChart);
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Wait for all threads in a feature to complete
+ */
+export async function threadsWaitAllCommand(feature, options) {
+  const timeoutMs = (options.timeout || 60) * 60 * 1000;
+  const pollInterval = 5000;
+  const start = Date.now();
+
+  console.log(chalk.cyan(`\n  Waiting for all threads in: ${feature}\n`));
+
+  while (Date.now() - start < timeoutMs) {
+    const threads = listThreads({ feature });
+    const active = threads.filter(t =>
+      t.status === THREAD_STATUS.PENDING || t.status === THREAD_STATUS.RUNNING
+    );
+
+    if (active.length === 0) {
+      const failed = threads.filter(t => t.status === THREAD_STATUS.FAILED);
+      if (failed.length > 0) {
+        console.log(chalk.yellow(`  ⚠ ${failed.length} thread(s) failed`));
+        process.exit(1);
+      }
+      console.log(chalk.green(`  ✓ All ${threads.length} threads completed`));
+      return;
+    }
+
+    process.stdout.write(`\r  Still running: ${active.length} thread(s)...`);
+    await new Promise(r => setTimeout(r, pollInterval));
+  }
+
+  console.error(chalk.red('\n  Timeout waiting for threads'));
+  process.exit(1);
+}
+
+/**
+ * Wait for any thread to complete
+ */
+export async function threadsWaitAnyCommand(feature, options) {
+  const timeoutMs = (options.timeout || 60) * 60 * 1000;
+  const pollInterval = 3000;
+  const start = Date.now();
+
+  console.log(chalk.cyan(`\n  Waiting for first thread to complete in: ${feature}\n`));
+
+  while (Date.now() - start < timeoutMs) {
+    const threads = listThreads({ feature });
+    const done = threads.find(t =>
+      t.status === THREAD_STATUS.COMPLETED || t.status === THREAD_STATUS.FAILED
+    );
+
+    if (done) {
+      const colorFn = STATUS_COLORS[done.status] || chalk.white;
+      console.log(`  ${colorFn('✓')} Thread ${done.id.substring(0, 8)} ${done.status}`);
+      if (done.agent) console.log(`    Agent: ${done.agent}`);
+      return;
+    }
+
+    await new Promise(r => setTimeout(r, pollInterval));
+  }
+
+  console.error(chalk.red('\n  Timeout waiting for thread'));
+  process.exit(1);
+}

package/src/commands/trust/trust.js

@@ -0,0 +1,205 @@
+/**
+ * Trust CLI — Trust level management for zero-touch execution
+ *
+ * Usage:
+ *   morph-spec trust status [feature]
+ *   morph-spec trust set <feature> <level> [reason]
+ *   morph-spec trust history
+ *   morph-spec trust auto-calculate <feature>
+ */
+
+import chalk from 'chalk';
+import {
+  getTrust,
+  setTrust,
+  clearTrustOverride,
+  getTrustHistory,
+  autoCalculateTrust,
+  TRUST_THRESHOLDS,
+  AUTO_APPROVE_GATES
+} from '../../lib/trust/trust-manager.js';
+
+/**
+ * Trust status — current trust level for a feature or all features
+ */
+export async function trustStatusCommand(featureName, options) {
+  if (featureName) {
+    const trust = getTrust(featureName);
+
+    console.log(chalk.bold(`\n  Trust Status — ${featureName}`));
+    console.log('  ' + '─'.repeat(50));
+
+    const levelColor = trust.level === 'maximum' ? chalk.green
+      : trust.level === 'high' ? chalk.cyan
+      : trust.level === 'medium' ? chalk.yellow
+      : chalk.red;
+
+    console.log(`  Level:       ${levelColor(trust.level.toUpperCase())}`);
+    console.log(`  Pass Rate:   ${Math.round((trust.passRate || 0) * 100)}%`);
+    console.log(`  Checkpoints: ${trust.passed || 0}/${trust.total || 0} passed`);
+    console.log(`  Source:      ${trust.source || 'calculated'}`);
+
+    if (trust.source === 'manual') {
+      console.log(chalk.yellow(`  Override:    ${trust.overrideReason || 'No reason provided'}`));
+    }
+
+    console.log(`\n  Auto-approved gates:`);
+    if (trust.autoApprove.length === 0) {
+      console.log(chalk.gray('    (none — manual approval required for all gates)'));
+    } else {
+      trust.autoApprove.forEach(g => console.log(chalk.green(`    ✓ ${g}`)));
+    }
+
+    console.log(`\n  Trust thresholds:`);
+    for (const [level, threshold] of Object.entries(TRUST_THRESHOLDS)) {
+      const gates = AUTO_APPROVE_GATES[level] || [];
+      const marker = trust.level === level ? chalk.bold(' ← current') : '';
+      console.log(`    ${level.padEnd(10)} ≥ ${Math.round(threshold * 100)}%  auto-approves: ${gates.join(', ') || 'none'}${marker}`);
+    }
+
+    console.log();
+  } else {
+    // Show all features
+    const history = getTrustHistory();
+    if (history.length === 0) {
+      console.log(chalk.yellow('\n  No features found.\n'));
+      return;
+    }
+
+    console.log(chalk.bold('\n  Trust Overview'));
+    console.log('  ' + '─'.repeat(70));
+    console.log(`  ${'Feature'.padEnd(25)} ${'Level'.padEnd(10)} ${'Pass%'.padEnd(8)} ${'CPs'.padEnd(8)} Phase`);
+    console.log('  ' + '─'.repeat(70));
+
+    for (const f of history) {
+      const levelColor = f.level === 'maximum' ? chalk.green
+        : f.level === 'high' ? chalk.cyan
+        : f.level === 'medium' ? chalk.yellow
+        : chalk.red;
+
+      console.log(
+        `  ${f.feature.padEnd(25)} ` +
+        `${levelColor(f.level.padEnd(10))} ` +
+        `${String(Math.round(f.passRate * 100) + '%').padEnd(8)} ` +
+        `${String(f.checkpointsTotal).padEnd(8)} ` +
+        `${f.phase || 'N/A'}`
+      );
+    }
+    console.log();
+  }
+}
+
+/**
+ * Trust set — manually override trust level
+ */
+export async function trustSetCommand(featureName, level, reason, options) {
+  if (!featureName || !level) {
+    console.error(chalk.red('Usage: morph-spec trust set <feature> <level> [reason]'));
+    console.error(chalk.gray('Levels: low, medium, high, maximum'));
+    process.exit(1);
+  }
+
+  const effectiveReason = reason || `Manual override to ${level}`;
+
+  try {
+    const result = setTrust(featureName, level, effectiveReason);
+
+    console.log(chalk.green(`\n✓ Trust updated for ${featureName}`));
+    console.log(`  Level:         ${result.level}`);
+    console.log(`  Auto-approves: ${result.autoApprove.join(', ') || 'none'}`);
+    console.log(`  Reason:        ${result.reason}`);
+    console.log(chalk.gray('\n  Note: Use "trust auto-calculate" to revert to calculated trust.\n'));
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Trust history — table of all features with checkpoint pass rates
+ */
+export async function trustHistoryCommand(options) {
+  const history = getTrustHistory();
+
+  console.log(chalk.bold('\n  Trust History'));
+  console.log('  ' + '─'.repeat(80));
+
+  if (history.length === 0) {
+    console.log(chalk.gray('  No features found.\n'));
+    return;
+  }
+
+  for (const f of history) {
+    const levelColor = f.level === 'maximum' ? chalk.green
+      : f.level === 'high' ? chalk.cyan
+      : f.level === 'medium' ? chalk.yellow
+      : chalk.red;
+
+    console.log(`\n  ${chalk.bold(f.feature)}`);
+    console.log(`    Trust:       ${levelColor(f.level)} (${Math.round(f.passRate * 100)}% pass rate)`);
+    console.log(`    Checkpoints: ${f.checkpointsPassed}/${f.checkpointsTotal} passed`);
+    console.log(`    Phase:       ${f.phase || 'N/A'} | Status: ${f.status || 'N/A'}`);
+    console.log(`    Source:      ${f.source}`);
+
+    if (f.autoApprove.length > 0) {
+      console.log(`    Auto-approves: ${chalk.green(f.autoApprove.join(', '))}`);
+    }
+  }
+
+  console.log('\n  ' + '─'.repeat(80));
+  console.log(chalk.gray(`  Total features: ${history.length}\n`));
+}
+
+/**
+ * Trust auto-calculate — recalculate from checkpoint history
+ */
+export async function trustAutoCalculateCommand(featureName, options) {
+  if (!featureName) {
+    console.error(chalk.red('Usage: morph-spec trust auto-calculate <feature>'));
+    process.exit(1);
+  }
+
+  try {
+    const result = autoCalculateTrust(featureName);
+
+    const levelColor = result.level === 'maximum' ? chalk.green
+      : result.level === 'high' ? chalk.cyan
+      : result.level === 'medium' ? chalk.yellow
+      : chalk.red;
+
+    console.log(chalk.bold(`\n  Trust Calculated — ${featureName}`));
+    console.log('  ' + '─'.repeat(40));
+    console.log(`  Level:         ${levelColor(result.level.toUpperCase())}`);
+    console.log(`  Pass Rate:     ${Math.round(result.passRate * 100)}%`);
+    console.log(`  Checkpoints:   ${result.passed}/${result.total} passed`);
+    console.log(`  Auto-approves: ${result.autoApprove.join(', ') || 'none'}`);
+
+    if (result.level === 'maximum') {
+      console.log(chalk.green('\n  ✓ Feature is eligible for zero-touch execution!'));
+      console.log(chalk.gray('  All gates will be auto-approved.\n'));
+    } else {
+      const nextLevel = result.passRate < TRUST_THRESHOLDS.medium ? 'medium'
+        : result.passRate < TRUST_THRESHOLDS.high ? 'high'
+        : 'maximum';
+      const needed = Math.ceil(TRUST_THRESHOLDS[nextLevel] * result.total) - result.passed;
+      console.log(chalk.gray(`\n  Next level: ${nextLevel} (need ${needed} more passing checkpoints)\n`));
+    }
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Trust clear — remove manual override
+ */
+export async function trustClearCommand(featureName, options) {
+  if (!featureName) {
+    console.error(chalk.red('Usage: morph-spec trust clear <feature>'));
+    process.exit(1);
+  }
+
+  clearTrustOverride(featureName);
+  console.log(chalk.green(`\n✓ Manual trust override cleared for ${featureName}`));
+  console.log(chalk.gray('  Trust will now be calculated from checkpoint history.\n'));
+}

package/src/{orchestrator.js → core/orchestrator.js}

@@ -4,18 +4,18 @@
  */
 
 import chalk from 'chalk';
-import { ProjectScanner } from './scanner/project-scanner.js';
-import { ContextSanitizer } from './sanitizer/context-sanitizer.js';
-import { LLMAnalyzer } from './llm/analyzer.js';
-import { ConfigGenerator } from './generator/config-generator.js';
-import { UserReview } from './ui/user-review.js';
-import { InteractiveWizard } from './ui/interactive-wizard.js';
-import { FileWriter } from './writer/file-writer.js';
+import { ProjectScanner } from '../scanner/project-scanner.js';
+import { ContextSanitizer } from '../sanitizer/context-sanitizer.js';
+import { LLMAnalyzer } from '../llm/analyzer.js';
+import { ConfigGenerator } from '../generator/config-generator.js';
+import { UserReview } from '../ui/user-review.js';
+import { InteractiveWizard } from '../ui/interactive-wizard.js';
+import { FileWriter } from '../writer/file-writer.js';
 import { readFile, access } from 'fs/promises';
 import { join } from 'path';
 
 /**
- * @typedef {import('./types/index.js').GeneratedConfigs} GeneratedConfigs
+ * @typedef {import('../types/index.js').GeneratedConfigs} GeneratedConfigs
  */
 
 /**