@polymorphism-tech/morph-spec 4.2.0 → 4.3.0

package/src/commands/agents/micro-agent.js

@@ -0,0 +1,112 @@
+/**
+ * Micro Agent CLI command
+ *
+ * Usage:
+ *   morph-spec micro-agent create <name> --base-agent=<agent> --mission="..." [--standards=file1,file2]
+ *   morph-spec micro-agent list
+ *   morph-spec micro-agent show <name>
+ */
+
+import chalk from 'chalk';
+import {
+  createMicroAgent, saveMicroAgent, listMicroAgents, getMicroAgent
+} from '../../lib/agents/micro-agent-factory.js';
+
+export async function microAgentCreateCommand(name, options) {
+  try {
+    if (!options.baseAgent) {
+      console.error(chalk.red('--base-agent is required'));
+      process.exit(1);
+    }
+    if (!options.mission) {
+      console.error(chalk.red('--mission is required'));
+      process.exit(1);
+    }
+
+    const standards = options.standards ? options.standards.split(',').map(s => s.trim()) : [];
+
+    const agent = createMicroAgent({
+      name,
+      baseAgent: options.baseAgent,
+      standards,
+      mission: options.mission,
+      tools: options.tools ? options.tools.split(',').map(t => t.trim()) : null
+    });
+
+    const filePath = saveMicroAgent(agent);
+
+    console.log(chalk.green(`\n  ✓ Micro-agent created: ${name}`));
+    console.log(`  Base agent: ${options.baseAgent}`);
+    console.log(`  Standards: ${standards.length > 0 ? standards.join(', ') : '(none)'}`);
+    console.log(`  Context estimate: ${agent.contextEstimate.total.toLocaleString()} tokens`);
+    console.log(`  Saved to: ${chalk.gray(filePath)}`);
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function microAgentListCommand(options) {
+  try {
+    const agents = listMicroAgents();
+
+    if (agents.length === 0) {
+      console.log(chalk.gray('\n  No micro-agents found. Create one with: morph-spec micro-agent create\n'));
+      return;
+    }
+
+    console.log(chalk.cyan(`\n  Micro-Agents (${agents.length})\n`));
+    console.log('  ' + 'Name'.padEnd(20) + ' ' + 'Base'.padEnd(20) + ' ' + 'Standards'.padEnd(12) + ' ' + 'Context');
+    console.log('  ' + '─'.repeat(70));
+
+    for (const agent of agents) {
+      console.log(
+        '  ' +
+        agent.id.padEnd(20) + ' ' +
+        (agent.baseAgent || '—').padEnd(20) + ' ' +
+        String(agent.standards).padEnd(12) + ' ' +
+        `${(agent.contextEstimate / 1000).toFixed(1)}K tokens`
+      );
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function microAgentShowCommand(name, options) {
+  try {
+    const agent = getMicroAgent(name);
+    if (!agent) {
+      console.error(chalk.red(`Micro-agent not found: ${name}`));
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n  Micro-Agent: ${name}\n`));
+    console.log(`  Base agent:  ${agent.baseAgent}`);
+    console.log(`  Domain:      ${agent.domain}`);
+    console.log(`  Created:     ${agent.createdAt}`);
+    console.log(`\n  Mission:\n  ${agent.mission}`);
+
+    if (agent.standards?.length > 0) {
+      console.log('\n  Standards:');
+      agent.standards.forEach(s => console.log(`    - ${s}`));
+    }
+
+    console.log('\n  Context estimate:');
+    console.log(`    Standards: ${agent.contextEstimate?.standards?.toLocaleString() || 0} tokens`);
+    console.log(`    Overhead:  ${agent.contextEstimate?.overhead?.toLocaleString() || 0} tokens`);
+    console.log(`    Total:     ${agent.contextEstimate?.total?.toLocaleString() || 0} tokens`);
+
+    if (options.showPrompt) {
+      console.log(chalk.cyan('\n  Generated Prompt:'));
+      console.log(agent.prompt);
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/agents/spawn-team.js

@@ -1,7 +1,10 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
+import { join } from 'path';
 import { getFeature } from '../../core/state/state-manager.js';
 import { orchestrateTeam } from '../../lib/orchestration/team-orchestrator.js';
+import { spawnParallel } from '../../lib/execution/parallel-executor.js';
+import { renderHOP } from '../../lib/hops/hop-composer.js';
 
 /**
  * Spawn Team Command - Generate agent team configurations
@@ -15,6 +18,35 @@ const program = new Command();
 /**
  * Spawn team action function
  */
+/**
+ * Spawn team in parallel mode
+ * --parallel backend,frontend,infra
+ */
+export async function spawnTeamParallelCommand(featureName, squads, options = {}) {
+  const squadList = squads.split(',').map(s => s.trim());
+  const maxConcurrent = parseInt(options.maxConcurrent || '3', 10);
+
+  console.log(chalk.cyan(`\n  Spawning ${squadList.length} parallel squads for: ${featureName}\n`));
+
+  const threadConfigs = squadList.map(squad => ({
+    agent: squad,
+    mission: `Implement ${squad} domain for ${featureName}`,
+    meta: { squad }
+  }));
+
+  try {
+    const threads = await spawnParallel({ feature: featureName, threadConfigs, maxConcurrent });
+    console.log(chalk.green(`  ✓ ${threads.length} threads spawned in parallel`));
+    for (const t of threads) {
+      console.log(`    ${chalk.gray(t.id.substring(0, 8))} — ${t.agent} (${t.status})`);
+    }
+    console.log(`\n  Monitor with: morph-spec threads wait-all ${featureName}\n`);
+  } catch (err) {
+    console.error(chalk.red(`  Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
 export async function spawnTeamCommand(featureName, options = {}) {
     try {
       // Get feature state
@@ -94,12 +126,44 @@ export async function spawnTeamCommand(featureName, options = {}) {
         });
       }
 
-      // Show Task tool usage
+      // Show Task tool usage (with HOP rendering)
       console.log(chalk.bold('\n📝 Task Tool Usage:'));
       console.log(chalk.gray('\nUse the following pattern to spawn the team:\n'));
 
-      console.log(chalk.cyan('```typescript'));
-      console.log(chalk.white(`{
+      // Try to render backend squad HOP if applicable
+      let hopPrompt = null;
+      const hasBackend = teamConfig.teammates.some(t => t.id.includes('dotnet') || t.id.includes('api') || t.id.includes('ef'));
+      if (hasBackend && options.useHop !== false) {
+        try {
+          const frameworkRoot = join(process.cwd(), 'framework');
+          const domainLeaders = teamConfig.teammates
+            .filter(t => t.tier === 2)
+            .map(t => `- ${t.id}: ${t.role}`)
+            .join('\n');
+          hopPrompt = renderHOP('hop-backend-squad', {
+            AGENT_ID: teamConfig.teamHierarchy.teamLead,
+            MISSION: `Implement ${featureName}`,
+            SPEC_SUMMARY: `Feature: ${featureName}. See spec.md for full details.`,
+            ADDITIONAL_LEADERS: domainLeaders,
+            TASKS: teamConfig.teammates.filter(t => t.tier === 3).map((t, i) => `- T${String(i+1).padStart(3,'0')}: ${t.role}`).join('\n'),
+            DELIVERABLES: 'See spec.md deliverables section',
+            CONSTRAINTS: 'Follow all architecture and security standards',
+            FEATURE_NAME: featureName
+          }, { frameworkRoot });
+        } catch {
+          hopPrompt = null;
+        }
+      }
+
+      if (hopPrompt) {
+        console.log(chalk.cyan('HOP-rendered prompt (backend squad):'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.white(hopPrompt.substring(0, 800) + (hopPrompt.length > 800 ? '\n...[truncated]' : '')));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.dim('\nFull HOP: morph-spec hop render hop-backend-squad output.md \'{...}\''));
+      } else {
+        console.log(chalk.cyan('```typescript'));
+        console.log(chalk.white(`{
   subagent_type: "general-purpose",
   description: "Implement ${featureName}",
   prompt: \`You are the Team Lead (${teamConfig.teamHierarchy.teamLead})...
@@ -123,7 +187,8 @@ Standards to follow: [coding.md, architecture.md]
 Deliverables: [list specific outputs]
 \`
 }`));
-      console.log(chalk.cyan('```\n'));
+        console.log(chalk.cyan('```\n'));
+      }
 
       // Show individual teammates
       console.log(chalk.bold('Individual Teammates:'));

package/src/commands/agents/squad-template.js

@@ -0,0 +1,146 @@
+/**
+ * Squad Template CLI command
+ *
+ * Usage:
+ *   morph-spec squad-template list
+ *   morph-spec squad-template use <template-id> --feature=<feature>
+ *   morph-spec squad-template show <template-id>
+ */
+
+import chalk from 'chalk';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+const SQUAD_TEMPLATES_DIR = join(process.cwd(), 'framework/squad-templates');
+
+function loadTemplate(id) {
+  const filePath = join(SQUAD_TEMPLATES_DIR, `${id}.json`);
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function listAllTemplates() {
+  if (!existsSync(SQUAD_TEMPLATES_DIR)) return [];
+  return readdirSync(SQUAD_TEMPLATES_DIR)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      try {
+        return JSON.parse(readFileSync(join(SQUAD_TEMPLATES_DIR, f), 'utf8'));
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+export async function squadTemplateListCommand(options) {
+  try {
+    const templates = listAllTemplates();
+
+    if (templates.length === 0) {
+      console.log(chalk.gray('\n  No squad templates found.\n'));
+      return;
+    }
+
+    console.log(chalk.cyan(`\n  Squad Templates (${templates.length})\n`));
+
+    for (const t of templates) {
+      console.log(`  ${chalk.bold(t.id)} — ${t.name}`);
+      console.log(`  ${chalk.gray(t.description)}`);
+      console.log(`  Agents: ${t.agents.map(a => a.id).join(', ')}`);
+      console.log(`  Parallel: ${t.parallel ? chalk.green('yes') : chalk.gray('no')} | Coordination: ${t.coordination}`);
+      console.log(`  Gain: ${chalk.cyan(t.estimatedParallelGain)}`);
+      console.log('');
+    }
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function squadTemplateUseCommand(templateId, options) {
+  try {
+    if (!options.feature) {
+      console.error(chalk.red('--feature is required'));
+      process.exit(1);
+    }
+
+    const template = loadTemplate(templateId);
+    if (!template) {
+      console.error(chalk.red(`Template not found: ${templateId}`));
+      console.error(chalk.gray('Run `morph-spec squad-template list` to see available templates'));
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n  Configuring Squad Template: ${templateId}\n`));
+    console.log(`  Feature: ${options.feature}`);
+    console.log(`  Template: ${template.name}`);
+    console.log(`  Agents: ${template.agents.length}`);
+    console.log(`  Parallel: ${template.parallel ? 'yes' : 'no'}`);
+
+    // Show spawn-team configuration
+    console.log(chalk.yellow('\n  To spawn this squad, use the Task tool with these configs:\n'));
+
+    for (const agent of template.agents) {
+      console.log(`  Agent: ${chalk.bold(agent.id)} (${agent.role})`);
+      console.log(`  Standards: ${agent.standards?.join(', ') || '(none)'}`);
+      const deliverable = template.deliverables?.[agent.id];
+      if (deliverable) {
+        console.log(`  Deliverable: ${deliverable}`);
+      }
+      console.log('');
+    }
+
+    console.log(chalk.gray('  See: morph-spec spawn-team --template=' + templateId + ' --feature=' + options.feature));
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function squadTemplateShowCommand(templateId, options) {
+  try {
+    const template = loadTemplate(templateId);
+    if (!template) {
+      console.error(chalk.red(`Template not found: ${templateId}`));
+      process.exit(1);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(template, null, 2));
+      return;
+    }
+
+    console.log(chalk.cyan(`\n  Squad Template: ${template.id}\n`));
+    console.log(`  Name:        ${template.name}`);
+    console.log(`  Description: ${template.description}`);
+    console.log(`  Parallel:    ${template.parallel ? chalk.green('yes') : chalk.gray('no')}`);
+    console.log(`  Coordinator: ${template.coordination}`);
+    console.log(`  Wait all:    ${template.waitForAll ? 'yes' : 'no'}`);
+    console.log(`  Gain:        ${template.estimatedParallelGain}`);
+
+    console.log('\n  Agents:');
+    for (const agent of template.agents) {
+      console.log(`    ${chalk.bold(agent.id)} — ${agent.role} (${agent.domain})`);
+      if (agent.standards?.length > 0) {
+        console.log(`      Standards: ${agent.standards.join(', ')}`);
+      }
+    }
+
+    if (template.deliverables) {
+      console.log('\n  Deliverables:');
+      for (const [agent, deliverable] of Object.entries(template.deliverables)) {
+        console.log(`    ${agent}: ${deliverable}`);
+      }
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/analytics/analytics.js

@@ -0,0 +1,176 @@
+/**
+ * Analytics CLI command — Metrics dashboards
+ *
+ * Usage:
+ *   morph-spec analytics feature <name>
+ *   morph-spec analytics context <name>
+ *   morph-spec analytics project [--period=30d]
+ */
+
+import chalk from 'chalk';
+import {
+  getFeatureAnalytics, getProjectAnalytics,
+  generateAsciiChart, generateTimelineChart,
+  recordEvent
+} from '../../lib/analytics/analytics-engine.js';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+// ============================================================================
+// Feature Analytics Dashboard
+// ============================================================================
+
+export async function analyticsFeatureCommand(featureName, options) {
+  try {
+    const analytics = getFeatureAnalytics(featureName);
+
+    console.log(chalk.cyan(`\n  Feature Analytics — ${featureName}\n`));
+    console.log('  ' + '─'.repeat(50));
+
+    console.log(`\n  Threads:`);
+    for (const [status, count] of Object.entries(analytics.threads)) {
+      console.log(`    ${status.padEnd(12)} ${count}`);
+    }
+
+    console.log(`\n  Performance:`);
+    console.log(`    Checkpoint pass rate:  ${analytics.checkpointPassRate}%`);
+    console.log(`    Total duration:        ${formatDuration(analytics.totalDuration)}`);
+    console.log(`    Total tool calls:      ${analytics.totalToolCalls}`);
+    console.log(`    Total tokens used:     ${analytics.totalTokensUsed.toLocaleString()}`);
+    console.log(`    Context optimizations: ${analytics.optimizationEvents}`);
+
+    if (Object.keys(analytics.threads).length > 0) {
+      console.log('\n' + generateAsciiChart(analytics.threads, { title: 'Threads by Status' }));
+    }
+
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Context Analytics Dashboard
+// ============================================================================
+
+export async function analyticsContextCommand(featureName, options) {
+  try {
+    // Load context events from JSONL
+    const contextLogPath = join(process.cwd(), '.morph/analytics/context-log.jsonl');
+
+    if (!existsSync(contextLogPath)) {
+      console.log(chalk.gray(`  No context analytics found for: ${featureName}`));
+      console.log(chalk.gray('  Run a session with context tracking to populate analytics.\n'));
+      return;
+    }
+
+    const lines = readFileSync(contextLogPath, 'utf8').trim().split('\n').filter(Boolean);
+    const events = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+    const featureEvents = events.filter(e => e.feature === featureName);
+
+    const tokenSamples = featureEvents.filter(e => e.type === 'token_usage');
+    const criticalMoments = featureEvents.filter(e => e.type === 'context_critical');
+    const optimizations = featureEvents.filter(e => e.type === 'context_optimized');
+
+    console.log(chalk.cyan(`\n  Context Analytics — ${featureName}\n`));
+    console.log('  ' + '─'.repeat(50));
+
+    if (tokenSamples.length === 0) {
+      console.log(chalk.gray('  No token usage data available.\n'));
+      return;
+    }
+
+    const avgTokens = Math.round(tokenSamples.reduce((s, e) => s + (e.data?.tokensUsed || 0), 0) / tokenSamples.length);
+    const peakTokens = Math.max(...tokenSamples.map(e => e.data?.tokensUsed || 0));
+    const avgUtilization = Math.round(tokenSamples.reduce((s, e) => s + (e.data?.utilization || 0), 0) / tokenSamples.length * 100);
+
+    console.log(`\n  Token Usage:`);
+    console.log(`    Average tokens:      ${avgTokens.toLocaleString()}`);
+    console.log(`    Peak tokens:         ${peakTokens.toLocaleString()}`);
+    console.log(`    Avg utilization:     ${avgUtilization}%`);
+    console.log(`    Critical moments:    ${criticalMoments.length}`);
+    console.log(`    Optimizations applied: ${optimizations.length}`);
+
+    // Optimization opportunities
+    if (criticalMoments.length > 0) {
+      console.log(chalk.yellow('\n  ⚠ Optimization Opportunities:'));
+      const recs = criticalMoments.flatMap(e => e.data?.recommendations || []);
+      const uniqueStrategies = [...new Set(recs.map(r => r.strategy))];
+      for (const strategy of uniqueStrategies) {
+        const rec = recs.find(r => r.strategy === strategy);
+        console.log(`    • ${strategy}: ${rec?.description || ''}`);
+        console.log(`      Savings: ${rec?.estimatedSavings || 'unknown'}`);
+      }
+    }
+
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Project-Wide Dashboard
+// ============================================================================
+
+export async function analyticsProjectCommand(options) {
+  try {
+    const analytics = getProjectAnalytics();
+
+    console.log(chalk.cyan(`\n  Project Analytics Dashboard — ${analytics.period}\n`));
+    console.log('  ' + '═'.repeat(55));
+
+    console.log(`\n  📊 Overview`);
+    console.log(`    Features tracked:   ${analytics.features}`);
+    console.log(`    Total threads:      ${analytics.threads.total}`);
+    console.log(`      Completed:        ${analytics.threads.completed}`);
+    console.log(`      Failed:           ${analytics.threads.failed}`);
+
+    console.log(`\n  ✓ Checkpoints`);
+    console.log(`    Total run:          ${analytics.checkpoints.total}`);
+    console.log(`    Passed:             ${analytics.checkpoints.passed}`);
+    console.log(`    Pass rate:          ${analytics.checkpoints.passRate}%`);
+
+    if (analytics.checkpoints.total > 0) {
+      const bar = buildBar(analytics.checkpoints.passRate, 30);
+      console.log(`    ${bar}`);
+    }
+
+    console.log(`\n  ⫸ Parallelization`);
+    console.log(`    Avg concurrency:    ${analytics.parallelization.avgConcurrency}x`);
+    console.log(`    Parallel threads:   ${analytics.parallelization.parallelThreads}`);
+
+    console.log(`\n  ⚡ Trust & Auto-Approval`);
+    console.log(`    Auto-approvals:     ${analytics.trust.autoApprovals}`);
+    console.log(`    Trust level changes: ${analytics.trust.trustChanges}`);
+
+    console.log(`\n  🧠 Context`);
+    console.log(`    Avg tokens/session: ${analytics.context.avgTokensPerSession.toLocaleString()}`);
+    console.log(`    Optimizations:      ${analytics.context.optimizations}`);
+
+    console.log('\n  ' + '─'.repeat(55));
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+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`;
+}
+
+function buildBar(pct, width) {
+  const filled = Math.round(pct / 100 * width);
+  const color = pct >= 90 ? chalk.green : pct >= 70 ? chalk.yellow : chalk.red;
+  return color('[' + '█'.repeat(filled) + '░'.repeat(width - filled) + `] ${pct}%`);
+}

package/src/commands/context/context-prime.js

@@ -0,0 +1,63 @@
+/**
+ * Context Prime CLI command — Load minimal context priming files
+ *
+ * Usage:
+ *   morph-spec prime feature   (outputs feature-prime.md to stdout)
+ *   morph-spec prime bug
+ *   morph-spec prime refactor
+ *   morph-spec prime design
+ *   morph-spec prime infra
+ */
+
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const PRIME_FILES = {
+  feature: '.morph/context/feature-prime.md',
+  bug: '.morph/context/bug-prime.md',
+  refactor: '.morph/context/refactor-prime.md',
+  design: '.morph/context/design-prime.md',
+  infra: '.morph/context/infra-prime.md'
+};
+
+const PRIME_TYPES = Object.keys(PRIME_FILES);
+
+export async function contextPrimeCommand(type, options) {
+  if (!type) {
+    console.log(chalk.cyan('\n  Available prime types:\n'));
+    for (const [key, path] of Object.entries(PRIME_FILES)) {
+      const exists = existsSync(join(process.cwd(), path));
+      const status = exists ? chalk.green('✓') : chalk.red('✗');
+      console.log(`  ${status} ${key.padEnd(10)} → ${path}`);
+    }
+    console.log('');
+    console.log(chalk.gray('  Usage: morph-spec prime <type>'));
+    console.log(chalk.gray('  Example: morph-spec prime feature\n'));
+    return;
+  }
+
+  if (!PRIME_TYPES.includes(type)) {
+    console.error(chalk.red(`Unknown prime type: ${type}`));
+    console.error(chalk.gray(`Valid types: ${PRIME_TYPES.join(', ')}`));
+    process.exit(1);
+  }
+
+  const filePath = join(process.cwd(), PRIME_FILES[type]);
+
+  if (!existsSync(filePath)) {
+    console.error(chalk.red(`Prime file not found: ${filePath}`));
+    console.error(chalk.gray('Run `morph-spec init` to initialize MORPH-SPEC files.'));
+    process.exit(1);
+  }
+
+  const content = readFileSync(filePath, 'utf8');
+
+  if (options.json) {
+    console.log(JSON.stringify({ type, path: filePath, content }));
+    return;
+  }
+
+  // Output to stdout — designed to be read into context
+  console.log(content);
+}

package/src/commands/context/core-four.js

@@ -0,0 +1,54 @@
+/**
+ * Core Four CLI command — Context/Model/Prompt/Tools dashboard
+ *
+ * Usage:
+ *   morph-spec core-four <feature>
+ *   morph-spec core-four <feature> --json
+ */
+
+import chalk from 'chalk';
+import { getCoreFour, formatCoreFour, initCoreFour } from '../../lib/context/core-four-tracker.js';
+import { loadState } from '../../core/state/state-manager.js';
+
+export async function coreFourCommand(featureName, options) {
+  try {
+    // Initialize with defaults if not already set
+    initCoreFour({
+      model: 'claude-sonnet-4-6',
+      contextWindow: 200000,
+      feature: featureName
+    });
+
+    // Try to populate context breakdown from feature state
+    try {
+      const state = loadState(false);
+      if (state?.features?.[featureName]) {
+        const feature = state.features[featureName];
+        // Attempt to estimate context breakdown from known files
+        const breakdown = {
+          'CLAUDE.md': 23000,
+          standards: feature.activeAgents ? feature.activeAgents.length * 500 : 0,
+          spec: feature.outputs?.includes('spec') ? 8000 : 0,
+          conversation: 5000,
+          other: 2000
+        };
+        const { updateContextBreakdown } = await import('../../lib/context/core-four-tracker.js');
+        updateContextBreakdown(breakdown);
+      }
+    } catch {
+      // Best-effort
+    }
+
+    if (options.json) {
+      const data = getCoreFour();
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    console.log('\n' + formatCoreFour());
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}