@polymorphism-tech/morph-spec 4.2.0 → 4.3.1

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);
+  }
+}

package/src/commands/mcp/mcp.js

@@ -0,0 +1,102 @@
+/**
+ * MCP CLI command — MCP server analysis and optimization
+ *
+ * Usage:
+ *   morph-spec mcp optimize
+ *   morph-spec mcp list
+ */
+
+import chalk from 'chalk';
+import { analyzeMCP } from '../../lib/context/mcp-optimizer.js';
+
+const STATUS_COLORS = {
+  used: chalk.green,
+  unused: chalk.red,
+  unknown: chalk.gray
+};
+
+function formatTokens(n) {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n);
+}
+
+export async function mcpOptimizeCommand(options) {
+  try {
+    const analysis = analyzeMCP();
+
+    if (!analysis.found) {
+      console.log(chalk.yellow(`\n  ⚠ ${analysis.message}\n`));
+      return;
+    }
+
+    console.log(chalk.cyan('\n  MCP Optimization Analysis\n'));
+    console.log('  ' + '─'.repeat(60));
+
+    console.log(`\n  Settings file: ${chalk.gray(analysis.settingsPath)}`);
+    console.log(`  Total servers: ${analysis.totalServers}`);
+    console.log(`  Total context overhead: ${chalk.yellow(formatTokens(analysis.totalOverhead) + ' tokens')}`);
+
+    if (analysis.unusedCount > 0) {
+      console.log(`  Unused servers: ${chalk.red(analysis.unusedCount)}`);
+      console.log(`  Potential savings: ${chalk.green(formatTokens(analysis.potentialSavings) + ' tokens')}`);
+    }
+
+    if (analysis.recommendations.length === 0) {
+      console.log(chalk.green('\n  ✓ MCP configuration looks optimized!\n'));
+      return;
+    }
+
+    console.log(chalk.yellow('\n  Recommendations:\n'));
+    for (const rec of analysis.recommendations) {
+      console.log(`  ${chalk.bold(rec.title)}`);
+      console.log(`  ${rec.description}`);
+      console.log(`  Savings: ${chalk.green(formatTokens(rec.estimatedSavings) + ' tokens')}`);
+      console.log(`  Action: ${chalk.cyan(rec.action)}`);
+      console.log('');
+    }
+
+    console.log('  ' + '─'.repeat(60));
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+export async function mcpListCommand(options) {
+  try {
+    const analysis = analyzeMCP();
+
+    if (!analysis.found) {
+      console.log(chalk.yellow(`\n  ⚠ ${analysis.message}\n`));
+      return;
+    }
+
+    if (analysis.servers.length === 0) {
+      console.log(chalk.gray('\n  No MCP servers configured.\n'));
+      return;
+    }
+
+    console.log(chalk.cyan('\n  Configured MCP Servers\n'));
+    console.log('  ' + 'Name'.padEnd(25) + ' ' + 'Status'.padEnd(10) + ' ' + 'Overhead');
+    console.log('  ' + '─'.repeat(50));
+
+    for (const server of analysis.servers) {
+      const colorFn = STATUS_COLORS[server.usageStatus] || chalk.white;
+      console.log(
+        '  ' +
+        server.name.padEnd(25) + ' ' +
+        colorFn(server.usageStatus.padEnd(10)) + ' ' +
+        formatTokens(server.overhead) + ' tokens'
+      );
+    }
+
+    console.log('\n  ' + `Total overhead: ${formatTokens(analysis.totalOverhead)} tokens`);
+    if (analysis.recommendations.length > 0) {
+      console.log(chalk.yellow(`  Run 'morph-spec mcp optimize' for recommendations`));
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/project/detect-agents.js

@@ -9,7 +9,7 @@ import { loadStandardsForAgent, getStandardsListForAgent } from '../../lib/stand
 import { resolveAgentsConfigPath } from '../../lib/stacks/stack-resolver.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const frameworkRoot = join(__dirname, '..', '..');
+const frameworkRoot = join(__dirname, '..', '..', '..');
 
 function loadAgentsConfig() {
   try {
@@ -123,6 +123,34 @@ export function detectAgentsCommand(input, options) {
   const config = loadAgentsConfig();
   const result = detectAgents(userInput, config);
 
+  // Stack-aware filtering: penalize stack-mismatched agents
+  try {
+    const projectConfigPath = join(process.cwd(), '.morph/config/config.json');
+    const projectConfig = JSON.parse(readFileSync(projectConfigPath, 'utf8'));
+    const stack = projectConfig?.project?.stack || projectConfig?.project?.language || '';
+    const isJsStack = stack === 'nodejs' || stack === 'javascript' || stack === 'nextjs';
+
+    if (isJsStack) {
+      const dotnetKeywords = ['dotnet', '.net', 'csharp', 'c#', 'blazor', 'razor', 'azure', 'bicep',
+        'ef core', 'entity framework', 'hangfire', 'mudblazor', 'fluent ui', 'asp.net'];
+      const hasExplicitDotnetRequest = dotnetKeywords.some(k => userInput.toLowerCase().includes(k));
+
+      if (!hasExplicitDotnetRequest) {
+        const dotnetAgents = new Set([
+          'dotnet-senior', 'azure-architect', 'ef-modeler', 'bicep-architect',
+          'blazor-builder', 'blazor-concurrency-validator', 'hangfire-orchestrator',
+          'azure-deploy-specialist'
+        ]);
+        result.core = result.core.filter(id => !dotnetAgents.has(id));
+        result.specialists = result.specialists.filter(id => !dotnetAgents.has(id));
+        result.all = result.all.filter(id => !dotnetAgents.has(id));
+        result.matches = result.matches.filter(m => !dotnetAgents.has(m.id));
+      }
+    }
+  } catch {
+    // Config not found or unreadable — skip stack filtering
+  }
+
   // Enrich with complexity analysis
   try {
     result.complexity = analyzeRequestComplexity(userInput);
@@ -141,7 +169,9 @@ export function detectAgentsCommand(input, options) {
   }
 
   // Enrich with skill paths for each detected agent
-  const allAgents = [...(config.agents.core || []), ...(config.agents.specialists || [])];
+  const allAgents = Object.entries(config.agents || {})
+    .filter(([id]) => !id.startsWith('_'))
+    .map(([id, agent]) => ({ id, ...agent }));
   result.skillPaths = result.all
     .map(id => {
       const agent = allAgents.find(a => a.id === id);

package/src/commands/project/detect.js

@@ -3,7 +3,7 @@ import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../../utils/logger.js';
 import { detectProject, getDetectionSummary } from '../../lib/detectors/index.js';
-import { ensureDir, writeFile } from '../../utils/file-copier.js';
+import { ensureDir, writeFile, readJson, writeJson, pathExists } from '../../utils/file-copier.js';
 
 export async function detectCommand(options) {
   const targetPath = options.path || process.cwd();
@@ -84,6 +84,16 @@ export async function detectCommand(options) {
       const standardsPath = join(standardsDir, 'inferred.md');
       await writeFile(standardsPath, results.inferred.markdown);
 
+      // Update config.json with detected stack and architecture
+      const configPath = join(targetPath, '.morph', 'config', 'config.json');
+      if (await pathExists(configPath)) {
+        const projectConfig = await readJson(configPath);
+        projectConfig.project = projectConfig.project || {};
+        projectConfig.project.stack = results.structure.stack;
+        projectConfig.project.architecture = results.structure.architecture;
+        await writeJson(configPath, projectConfig);
+      }
+
       spinner.succeed('Results saved!');
       logger.dim(`  - ${logPath}`);
       logger.dim(`  - ${standardsPath}`);