@polymorphism-tech/morph-spec 4.8.19 → 4.9.0

package/src/core/state/state-manager.js

@@ -5,7 +5,7 @@
  * Used both by CLI commands and internal automation.
  */
 
-import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from 'fs';
+import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { detectWorkflow } from '../workflows/workflow-detector.js';
 import { getAllOutputPaths, getOutputPath } from '../paths/output-schema.js';
@@ -137,10 +137,29 @@ export function saveState(state) {
     mkdirSync(stateDir, { recursive: true });
   }
 
-  // Atomic write: write to temp then rename to avoid partial-write corruption
-  const tmpPath = statePath + '.tmp';
+  // Atomic write: write to a per-process temp file then rename.
+  // Per-process name prevents two concurrent CLI invocations (e.g. `task done && task start`)
+  // from clobbering each other's temp file on Windows.
+  const tmpPath = `${statePath}.tmp.${process.pid}`;
   writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf8');
-  renameSync(tmpPath, statePath);
+
+  // Retry rename on EPERM — Windows holds a brief exclusive lock on the target
+  // when another process is reading it; a short backoff resolves the contention.
+  const MAX_RETRIES = 5;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      renameSync(tmpPath, statePath);
+      return;
+    } catch (err) {
+      if (err.code === 'EPERM' && attempt < MAX_RETRIES) {
+        // Synchronous sleep: CPU-friendly, works on Node.js main thread (v9.4+)
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50 * (attempt + 1));
+      } else {
+        try { unlinkSync(tmpPath); } catch { /* ignore cleanup errors */ }
+        throw err;
+      }
+    }
+  }
 }
 
 /**
@@ -241,7 +260,7 @@ async function ensureFeature(featureName, options = {}) {
 
     state.features[featureName] = {
       status: "draft",
-      workflow: workflowId, // auto | fast-track | standard | full-morph | design-impl | ui-refresh
+      workflow: workflowId, // auto | standard | nodejs-cli
       workflowDetection,
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
@@ -259,20 +278,7 @@ async function ensureFeature(featureName, options = {}) {
         pending: 0
       },
       checkpoints: [],
-      threadMetrics: {
-        totalThreads: 0,
-        parallelPeak: 0,
-        avgDuration: 0,
-        checkpointPassRate: 100
-      },
-      trustConfig: {
-        level: 'low',
-        history: [],
-        autoApprove: {
-          design: false,
-          tasks: false
-        }
-      },
+      trustConfig: {},
       contextBundles: [],
       fileChanges: []
     };
@@ -515,20 +521,11 @@ export async function markOutput(featureName, outputType) {
 
   const normalized = normalizeOutputType(outputType);
 
-  // Initialize outputs on demand (not pre-stored since v5.0.0)
+  // Initialize outputs on demand (not pre-stored)
   if (!state.features[featureName].outputs) {
     state.features[featureName].outputs = getAllOutputPaths(featureName);
   }
 
-  // Define all valid output types (both camelCase and kebab-case alternatives)
-  const validTypes = [
-    'proposal', 'spec', 'contracts', 'tasks', 'decisions', 'recap',
-    'uiDesignSystem', 'ui-design-system',
-    'uiMockups', 'ui-mockups',
-    'uiComponents', 'ui-components',
-    'uiFlows', 'ui-flows'
-  ];
-
   if (!state.features[featureName].outputs[normalized]) {
     // Try to find closest match for better error message
     const validCamelCaseTypes = Object.keys(state.features[featureName].outputs);
@@ -551,9 +548,8 @@ export async function markOutput(featureName, outputType) {
     }
 
     errorMsg += `\n\nValid types:\n`;
-    errorMsg += `  - Standard: proposal, spec, contracts, tasks, decisions, recap\n`;
-    errorMsg += `  - UI/UX: uiDesignSystem, uiMockups, uiComponents, uiFlows\n`;
-    errorMsg += `\nNote: UI types also accept kebab-case (e.g., 'ui-design-system')`;
+    errorMsg += `  ${validCamelCaseTypes.join(', ')}\n`;
+    errorMsg += `\nNote: UI types also accept kebab-case (e.g., 'ui-design-system', 'schema-analysis')`;
 
     throw new Error(errorMsg);
   }
@@ -575,31 +571,9 @@ export async function markOutput(featureName, outputType) {
     });
   }
 
-  // If marking tasks output, try to sync task count from state tasks array
-  if (normalized === 'tasks') {
-    syncTasksCount(state.features[featureName]);
-  }
-
   saveState(state);
 }
 
-/**
- * Sync progress counters from taskList array into feature.progress
- * @param {Object} feature - Feature object
- */
-function syncTasksCount(feature) {
-  const list = feature.taskList;
-  if (!Array.isArray(list) || list.length === 0) return;
-  const completed = list.filter(t => t.status === 'completed').length;
-  feature.progress = {
-    total: list.length,
-    completed,
-    inProgress: list.filter(t => t.status === 'in_progress').length,
-    pending: list.filter(t => t.status === 'pending').length,
-    percentage: Math.round((completed / list.length) * 100)
-  };
-}
-
 /**
  * Track a file change for a feature
  * @param {string} featureName - Feature name

package/src/core/workflows/workflow-detector.js

@@ -242,11 +242,11 @@ export async function detectWorkflow(options) {
   if (workflows.length === 0) {
     // Fallback if no configs found
     return {
-      workflowId: 'full-morph',
+      workflowId: 'standard',
       confidence: 0.5,
       matchedKeywords: [],
       estimatedComplexity: { files: 0, lines: 0, components: 0, hasInfra: false },
-      reasoning: 'No workflow configs found - using full-morph as fallback',
+      reasoning: 'No workflow configs found - using standard as fallback',
       alternativeWorkflows: []
     };
   }
@@ -286,8 +286,8 @@ export async function detectWorkflow(options) {
       (priorityScore * priorityWeight) +
       (contextScore * contextWeight);
 
-    // Penalty for workflows with no keyword matches (unless it's full-morph fallback)
-    if (keywordMatch.matched.length === 0 && workflow.id !== 'full-morph') {
+    // Penalty for workflows with no keyword matches
+    if (keywordMatch.matched.length === 0) {
       totalScore *= 0.5; // 50% penalty for no keyword match
     }
 
@@ -382,84 +382,6 @@ export function listWorkflows(projectPath = '.') {
   }));
 }
 
-// ============================================================================
-// Parallel, Fusion, Long-Running, Zero-Touch Detection
-// ============================================================================
-
-/**
- * Detect if parallel execution mode should be used for a feature.
- * Based on dependency graph analysis: if feature has independent task squads,
- * recommend parallel mode.
- *
- * @param {string} feature - Feature name
- * @param {string} [projectPath='.'] - Project path
- * @returns {Object} { useParallel: boolean, reason: string, squads: Array }
- */
-export async function detectParallelMode(feature, projectPath = '.') {
-  try {
-    const { getExecutionPlan } = await import('../../lib/threads/thread-coordinator.js').catch(() => {
-      // thread-coordinator may not exist yet — graceful fallback
-      return { getExecutionPlan: null };
-    });
-
-    if (!getExecutionPlan) {
-      return { useParallel: false, reason: 'thread-coordinator not available', squads: [] };
-    }
-
-    const plan = getExecutionPlan(feature);
-
-    if (!plan.valid) {
-      return { useParallel: false, reason: plan.error, squads: [] };
-    }
-
-    const parallelPhases = plan.phases.filter(p => p.canRunParallel);
-    const useParallel = parallelPhases.length > 0 && plan.stats.parallelizationRatio > 30;
-
-    return {
-      useParallel,
-      reason: useParallel
-        ? `${plan.stats.parallelizationRatio}% of tasks are parallelizable across ${parallelPhases.length} phases`
-        : 'Tasks are mostly sequential — parallel mode would not improve throughput',
-      parallelizationRatio: plan.stats.parallelizationRatio,
-      parallelPhases: parallelPhases.length,
-      squads: parallelPhases.map(p => p.tasks)
-    };
-  } catch {
-    return { useParallel: false, reason: 'Dependency analysis failed', squads: [] };
-  }
-}
-
-/**
- * Detect if a request needs fusion workflow (uncertainty → run N agents → best-of-N)
- * @param {string} userRequest
- * @returns {boolean}
- */
-export function detectFusionNeed(userRequest) {
-  const fusionKeywords = [
-    'uncertain', 'uncertainty', 'critical decision', 'compare approaches',
-    'best approach', 'prototype', 'explore options', 'which is better',
-    'not sure how', 'multiple solutions', 'benchmark'
-  ];
-  const req = userRequest.toLowerCase();
-  return fusionKeywords.some(kw => req.includes(kw));
-}
-
-/**
- * Detect if a request needs long-running workflow (L-Thread with stop hooks)
- * @param {string} userRequest
- * @returns {boolean}
- */
-export function detectLongRunningNeed(userRequest) {
-  const longRunningKeywords = [
-    'autonomous', 'large scope', 'full system', 'end to end', 'e2e',
-    'complete implementation', 'no interruption', 'long running', 'unattended'
-  ];
-  const req = userRequest.toLowerCase();
-  const fileCountMatch = req.match(/(\d+)\+?\s+files?/);
-  const fileCount = fileCountMatch ? parseInt(fileCountMatch[1]) : 0;
-  return longRunningKeywords.some(kw => req.includes(kw)) || fileCount > 10;
-}
-
 /**
  * Check zero-touch eligibility for a feature (requires trust-manager)
  * @param {string} feature
@@ -467,14 +389,14 @@ export function detectLongRunningNeed(userRequest) {
  */
 export async function checkZeroTouchEligibility(feature) {
   try {
-    const { getTrustLevel } = await import('../../lib/trust/trust-manager.js').catch(() => ({
-      getTrustLevel: null
+    const { getTrust } = await import('../../lib/trust/trust-manager.js').catch(() => ({
+      getTrust: null
     }));
 
-    if (!getTrustLevel) return false;
+    if (!getTrust) return false;
 
-    const level = getTrustLevel(feature);
-    return level === 'maximum';
+    const trust = getTrust(feature);
+    return trust.level === 'auto';
   } catch {
     return false;
   }

package/src/lib/phase-chain/phase-validator.js

@@ -0,0 +1,330 @@
+/**
+ * Phase Validator — centralized phase validation and eligibility checking.
+ *
+ * Exports: PHASES, validatePhase, computePassRate, checkPhaseEligibility
+ *
+ * Callers:
+ *   - src/commands/state/advance-phase.js
+ *   - src/commands/state/phase-runner.js
+ *   - src/commands/project/status.js
+ */
+
+import fs from 'fs';
+import { existsSync } from 'fs';
+import path, { join } from 'path';
+import { loadState, derivePhase, getFeature } from '../../core/state/state-manager.js';
+import { getWorkflowConfig } from '../../core/workflows/workflow-detector.js';
+import { shouldAutoApprove } from '../trust/trust-manager.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase definitions (from validate-phase.js)
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const PHASES = {
+  'proposal': {
+    order: 0,
+    name: 'FASE 0: PROPOSAL',
+    requiredOutputs: [],
+    description: 'Initial proposal and agent detection'
+  },
+  'setup': {
+    order: 1,
+    name: 'FASE 1: SETUP',
+    requiredOutputs: ['proposal.md'],
+    description: 'Load context and standards'
+  },
+  'uiux': {
+    order: 2,
+    name: 'FASE 1.5: UI/UX DESIGN',
+    requiredOutputs: ['proposal.md'],
+    optionalOutputs: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'],
+    description: 'UI/UX design (conditional - only if frontend)',
+    optional: true
+  },
+  'design': {
+    order: 3,
+    name: 'FASE 2: DESIGN',
+    requiredOutputs: ['proposal.md'],
+    description: 'Technical specification and contracts'
+  },
+  'clarify': {
+    order: 4,
+    name: 'FASE 3: CLARIFY',
+    requiredOutputs: ['proposal.md', 'spec.md'],
+    description: 'Clarify ambiguities and edge cases'
+  },
+  'tasks': {
+    order: 5,
+    name: 'FASE 4: TASKS',
+    requiredOutputs: ['proposal.md', 'spec.md'],
+    description: 'Break down into executable tasks'
+  },
+  'implement': {
+    order: 6,
+    name: 'FASE 5: IMPLEMENT',
+    requiredOutputs: ['proposal.md', 'spec.md'],
+    description: 'Execute tasks and implement code'
+  },
+  'sync': {
+    order: 7,
+    name: 'FASE 6: SYNC',
+    requiredOutputs: ['proposal.md', 'spec.md', 'decisions.md'],
+    description: 'Sync decisions to project standards',
+    optional: true
+  }
+};
+
+// Map output filenames to their phase subfolders
+const OUTPUT_PHASE_MAP = {
+  'proposal.md': '0-proposal',
+  'schema-analysis.md': '1-design',
+  'spec.md': '1-design',
+  'clarifications.md': '1-design',
+  'contracts.cs': '1-design',
+  'decisions.md': '1-design',
+  'ui-design-system.md': '2-ui',
+  'ui-mockups.md': '2-ui',
+  'ui-components.md': '2-ui',
+  'ui-flows.md': '2-ui',
+  'tasks.md': '3-tasks',
+  'recap.md': '4-implement'
+};
+
+function checkOutput(featurePath, outputFile) {
+  const phaseDir = OUTPUT_PHASE_MAP[outputFile] || '';
+  const filePath = path.join(featurePath, phaseDir, outputFile);
+  return fs.existsSync(filePath);
+}
+
+/**
+ * Validate phase prerequisites for a feature.
+ * Used by advance-phase.js before advancing.
+ */
+export function validatePhase(featureName, targetPhase) {
+  const featurePath = path.join(process.cwd(), '.morph/features', featureName);
+
+  if (!fs.existsSync(featurePath)) {
+    return {
+      valid: false,
+      error: `Feature directory not found: ${featurePath}`,
+      suggestion: `Run 'morph-spec state init ${featureName}' to start`,
+      missingOutputs: [],
+      phase: null
+    };
+  }
+
+  const phaseDefinition = PHASES[targetPhase];
+  if (!phaseDefinition) {
+    return {
+      valid: false,
+      error: `Unknown phase: ${targetPhase}`,
+      validPhases: Object.keys(PHASES),
+      missingOutputs: [],
+      phase: null
+    };
+  }
+
+  const missingOutputs = [];
+  for (const output of phaseDefinition.requiredOutputs) {
+    if (!checkOutput(featurePath, output)) {
+      missingOutputs.push(output);
+    }
+  }
+
+  // Special validation: implement phase requires tasks.md to have actual tasks
+  if (targetPhase === 'implement') {
+    const tasksFilePath = path.join(featurePath, '3-tasks', 'tasks.md');
+    if (fs.existsSync(tasksFilePath)) {
+      const content = fs.readFileSync(tasksFilePath, 'utf-8');
+      const taskCount = (content.match(/^###\s+T\d+/gm) || []).length;
+      if (taskCount === 0) {
+        missingOutputs.push(`tasks.md exists but has no task entries — add ### T001 — Task title entries`);
+      }
+    }
+  }
+
+  // Warn if skipping phases
+  let stateWarning = null;
+  try {
+    const feature = getFeature(featureName);
+    if (feature) {
+      const currentPhaseOrder = PHASES[feature.phase]?.order ?? -1;
+      const targetPhaseOrder = phaseDefinition.order;
+      if (targetPhaseOrder > currentPhaseOrder + 1) {
+        stateWarning = `Skipping phases: current is '${feature.phase}' (order ${currentPhaseOrder}), target is '${targetPhase}' (order ${targetPhaseOrder})`;
+      }
+    }
+  } catch {
+    // State file may not exist
+  }
+
+  return {
+    valid: missingOutputs.length === 0,
+    error: null,
+    missingOutputs,
+    phase: phaseDefinition,
+    featurePath,
+    stateWarning
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase eligibility
+// ─────────────────────────────────────────────────────────────────────────────
+
+const PHASE_ORDER = ['proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
+
+function getNextPhase(currentPhase) {
+  const idx = PHASE_ORDER.indexOf(currentPhase);
+  if (idx === -1 || idx >= PHASE_ORDER.length - 1) return null;
+  return PHASE_ORDER[idx + 1];
+}
+
+/**
+ * Compute overall validation pass rate from validationHistory.
+ * Returns null when no history exists.
+ */
+export function computePassRate(validationHistory) {
+  if (!validationHistory || Object.keys(validationHistory).length === 0) return null;
+  const entries = Object.values(validationHistory);
+  const passed = entries.filter(e => e.status === 'passed').length;
+  return entries.length > 0 ? passed / entries.length : null;
+}
+
+// Map output type names to file paths for eligibility checks
+const OUTPUT_PATH_MAP = {
+  'proposal': '0-proposal/proposal.md',
+  'spec': '1-design/spec.md',
+  'contracts': '1-design/contracts.cs',
+  'tasks': '3-tasks/tasks.md',
+  'schemaAnalysis': '1-design/schema-analysis.md',
+};
+
+function getMissingRequiredOutputs(featureName, phase, projectPath) {
+  const phaseDef = PHASES[phase];
+  if (!phaseDef?.requiredOutputs) return [];
+
+  const missing = [];
+  const featureBase = join(projectPath, '.morph', 'features', featureName);
+
+  for (const output of phaseDef.requiredOutputs) {
+    const relPath = OUTPUT_PATH_MAP[output];
+    if (relPath && !existsSync(join(featureBase, relPath))) {
+      missing.push(output);
+    }
+  }
+
+  return missing;
+}
+
+function getBlockedTasks(feature) {
+  const history = feature.validationHistory || {};
+  return Object.entries(history)
+    .filter(([, entry]) => entry.status === 'blocked')
+    .map(([taskId]) => taskId);
+}
+
+/**
+ * Check whether a feature is eligible to auto-advance to the next phase.
+ * Used by phase-runner.js.
+ */
+export function checkPhaseEligibility(featureName, opts = {}) {
+  const projectPath = opts.projectPath || process.cwd();
+
+  const state = loadState(false);
+  if (!state) {
+    return {
+      eligible: false,
+      blockers: [{ type: 'state_error', items: ['state.json not found'] }],
+      currentPhase: 'unknown',
+      nextPhase: null,
+      passRate: null,
+    };
+  }
+
+  const feature = state.features?.[featureName];
+  if (!feature) {
+    return {
+      eligible: false,
+      blockers: [{ type: 'state_error', items: [`Feature '${featureName}' not found in state.json`] }],
+      currentPhase: 'unknown',
+      nextPhase: null,
+      passRate: null,
+    };
+  }
+
+  const featureFolderPath = join(projectPath, '.morph', 'features', featureName);
+  const currentPhase = feature.phase || derivePhase(featureFolderPath);
+  const nextPhase = getNextPhase(currentPhase);
+
+  if (!nextPhase) {
+    return {
+      eligible: false,
+      blockers: [{ type: 'state_error', items: ['Feature is at the final phase'] }],
+      currentPhase,
+      nextPhase: null,
+      passRate: null,
+    };
+  }
+
+  let workflowConfig = null;
+  if (feature.workflow && feature.workflow !== 'auto') {
+    try {
+      workflowConfig = getWorkflowConfig(feature.workflow);
+    } catch {
+      // Non-blocking: fall through to defaults
+    }
+  }
+
+  const minPassRate = workflowConfig?.phaseChain?.pauseOn
+    ? 0.80
+    : workflowConfig?.eligibility?.minPassRate ?? 0.80;
+
+  const blockers = [];
+
+  const missingOutputs = getMissingRequiredOutputs(featureName, currentPhase, projectPath);
+  if (missingOutputs.length > 0) {
+    blockers.push({ type: 'missing_outputs', items: missingOutputs });
+  }
+
+  const blockedTasks = getBlockedTasks(feature);
+  if (blockedTasks.length > 0) {
+    blockers.push({ type: 'blocked_tasks', items: blockedTasks });
+  }
+
+  const passRate = computePassRate(feature.validationHistory);
+  if (passRate !== null && passRate < minPassRate) {
+    blockers.push({
+      type: 'low_pass_rate',
+      current: passRate,
+      required: minPassRate,
+    });
+  }
+
+  try {
+    const requiredGateMap = { design: 'design', tasks: 'tasks', uiux: 'uiux' };
+    const gate = requiredGateMap[currentPhase];
+    if (gate) {
+      const trustResult = shouldAutoApprove(featureName, gate);
+      if (!trustResult.autoApprove) {
+        const gateStatus = feature.approvalGates?.[gate];
+        if (!gateStatus?.approved) {
+          blockers.push({
+            type: 'trust_too_low',
+            items: [`Gate '${gate}' requires trust level ${trustResult.level || 'medium+'}`],
+          });
+        }
+      }
+    }
+  } catch {
+    // Trust manager unavailable — non-blocking
+  }
+
+  return {
+    eligible: blockers.length === 0,
+    blockers,
+    currentPhase,
+    nextPhase,
+    passRate,
+  };
+}

package/src/lib/stack/stack-profile.js

@@ -0,0 +1,88 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/** @typedef {'nextjs'|'blazor'|'dotnet'|'nodejs-cli'|'unknown'} StackName */
+
+/**
+ * @typedef {Object} StackProfile
+ * @property {StackName} stack
+ * @property {boolean} isDotnet
+ * @property {boolean} isNextjs
+ * @property {string[]} defaultValidators
+ * @property {string[]} checkpointValidators
+ * @property {'contracts'|'contractsTs'} contractsOutputType
+ * @property {'contracts.cs'|'contracts.ts'} contractsFilename
+ * @property {'csharp'|'typescript'} contractsLanguage
+ */
+
+const DOTNET_STACKS = new Set(['dotnet', 'blazor', 'aspnet', 'dotnet-blazor']);
+const NEXTJS_STACKS = new Set(['nextjs', 'next', 'next.js']);
+const NO_VALIDATOR_STACKS = new Set(['nodejs-cli', 'node-cli', 'cli']);
+
+const PROFILES = {
+  dotnet: {
+    isDotnet: true, isNextjs: false,
+    defaultValidators: ['architecture', 'packages'],
+    checkpointValidators: ['architecture', 'packages', 'design-system', 'security'],
+    contractsOutputType: 'contracts',
+    contractsFilename: 'contracts.cs',
+    contractsLanguage: 'csharp',
+  },
+  nextjs: {
+    isDotnet: false, isNextjs: true,
+    defaultValidators: ['nextjs-component'],
+    checkpointValidators: ['nextjs-component', 'css'],
+    contractsOutputType: 'contractsTs',
+    contractsFilename: 'contracts.ts',
+    contractsLanguage: 'typescript',
+  },
+  empty: {
+    isDotnet: false, isNextjs: false,
+    defaultValidators: [],
+    checkpointValidators: [],
+    contractsOutputType: 'contracts',
+    contractsFilename: 'contracts.cs',
+    contractsLanguage: 'csharp',
+  },
+};
+
+/**
+ * Read project stack from .morph/config/config.json.
+ * @param {string} cwd - Project root
+ * @returns {string|null}
+ */
+function readStack(cwd) {
+  const configPath = join(cwd, '.morph', 'config', 'config.json');
+  if (!existsSync(configPath)) return null;
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf8')).project?.stack ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the StackProfile for the current project.
+ * @param {string} [cwd] - Project root. Defaults to process.cwd().
+ * @param {string} [stackOverride] - Skip config read and use this stack directly.
+ * @returns {StackProfile}
+ */
+export function getStackProfile(cwd, stackOverride) {
+  const root = cwd ?? process.cwd();
+  const raw = stackOverride ?? readStack(root);
+  const stack = raw?.toLowerCase() ?? 'unknown';
+
+  let profile;
+  if (NEXTJS_STACKS.has(stack)) {
+    profile = PROFILES.nextjs;
+  } else if (NO_VALIDATOR_STACKS.has(stack)) {
+    profile = PROFILES.empty;
+  } else if (DOTNET_STACKS.has(stack) || stack === 'unknown') {
+    profile = PROFILES.dotnet;
+  } else {
+    // Unknown non-.NET stack → empty validators, dotnet contracts (backward compat)
+    profile = PROFILES.empty;
+  }
+
+  return { stack, ...profile };
+}