@polymorphism-tech/morph-spec 4.8.19 → 4.9.0

package/src/lib/phase-chain/eligibility-checker.js

@@ -1,243 +0,0 @@
-/**
- * Phase Eligibility Checker
- *
- * Determines whether a feature is eligible to auto-advance to the next phase.
- * Used by phase-runner.js and the dispatch.js PostToolUse hook.
- *
- * Eligibility criteria (all must pass):
- *   1. Required outputs for the current phase exist on disk
- *   2. No tasks in state with status = 'blocked'
- *   3. validationHistory passRate >= minPassRate (from workflow config)
- *   4. Trust level meets the workflow's trustLevel requirement
- */
-
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { loadState } from '../../core/state/state-manager.js';
-import { getWorkflowConfig } from '../../core/workflows/workflow-detector.js';
-import { derivePhase } from '../../core/state/state-manager.js';
-import { PHASES } from '../../commands/state/validate-phase.js';
-import { shouldAutoApprove } from '../trust/trust-manager.js';
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Types (JSDoc)
-// ─────────────────────────────────────────────────────────────────────────────
-
-/**
- * @typedef {Object} EligibilityBlocker
- * @property {'missing_outputs'|'blocked_tasks'|'low_pass_rate'|'trust_too_low'|'state_error'} type
- * @property {string[]} [items] - Specific items causing the block
- * @property {number} [current] - Current value (for rate/level comparisons)
- * @property {number|string} [required] - Required value
- */
-
-/**
- * @typedef {Object} EligibilityResult
- * @property {boolean} eligible
- * @property {EligibilityBlocker[]} blockers
- * @property {string} currentPhase
- * @property {string|null} nextPhase
- * @property {number|null} passRate - Current validation pass rate (null if no data)
- */
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-
-/** Phase order (canonical from advance-phase.js) */
-const PHASE_ORDER = ['proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
-
-/**
- * Get the next phase in the standard sequence.
- * Returns null when at the last phase.
- */
-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 the overall validation pass rate from validationHistory.
- * Returns null when no history exists.
- *
- * @param {Object} validationHistory - feature.validationHistory
- * @returns {number|null}
- */
-export function computePassRate(validationHistory) {
-  if (!validationHistory || Object.keys(validationHistory).length === 0) return null;
-
-  const entries = Object.values(validationHistory);
-  const total = entries.length;
-  const passed = entries.filter(e => e.status === 'passed').length;
-
-  return total > 0 ? passed / total : null;
-}
-
-/**
- * Check if required outputs exist on disk for the given phase.
- *
- * @param {string} featureName
- * @param {string} phase
- * @param {string} projectPath
- * @returns {string[]} Array of missing output descriptions
- */
-function getMissingRequiredOutputs(featureName, phase, projectPath) {
-  const phaseDef = PHASES[phase];
-  if (!phaseDef?.requiredOutputs) return [];
-
-  const missing = [];
-  const featureBase = join(projectPath, '.morph', 'features', featureName);
-
-  // Map output type names to common file paths
-  const outputPathMap = {
-    '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',
-  };
-
-  for (const output of phaseDef.requiredOutputs) {
-    const relPath = outputPathMap[output];
-    if (relPath && !existsSync(join(featureBase, relPath))) {
-      missing.push(output);
-    }
-  }
-
-  return missing;
-}
-
-/**
- * Get tasks that are blocked (attempt >= 3, no resolution).
- *
- * @param {Object} feature - Feature state object
- * @returns {string[]} Array of blocked task IDs
- */
-function getBlockedTasks(feature) {
-  const history = feature.validationHistory || {};
-  return Object.entries(history)
-    .filter(([, entry]) => entry.status === 'blocked')
-    .map(([taskId]) => taskId);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Main export
-// ─────────────────────────────────────────────────────────────────────────────
-
-/**
- * Check whether a feature is eligible to auto-advance to the next phase.
- *
- * @param {string} featureName
- * @param {Object} [opts]
- * @param {string} [opts.projectPath] - Project root (defaults to cwd)
- * @param {boolean} [opts.dryRun] - Only compute, don't enforce
- * @returns {EligibilityResult}
- */
-export function checkPhaseEligibility(featureName, opts = {}) {
-  const projectPath = opts.projectPath || process.cwd();
-
-  // ── Load state ────────────────────────────────────────────────────────────
-  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,
-    };
-  }
-
-  // ── Derive current phase ──────────────────────────────────────────────────
-  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,
-    };
-  }
-
-  // ── Load workflow config ──────────────────────────────────────────────────
-  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  // Default minimum
-    : workflowConfig?.eligibility?.minPassRate ?? 0.80;
-
-  const blockers = [];
-
-  // ── Check 1: Missing required outputs ────────────────────────────────────
-  const missingOutputs = getMissingRequiredOutputs(featureName, currentPhase, projectPath);
-  if (missingOutputs.length > 0) {
-    blockers.push({ type: 'missing_outputs', items: missingOutputs });
-  }
-
-  // ── Check 2: Blocked tasks ────────────────────────────────────────────────
-  const blockedTasks = getBlockedTasks(feature);
-  if (blockedTasks.length > 0) {
-    blockers.push({ type: 'blocked_tasks', items: blockedTasks });
-  }
-
-  // ── Check 3: Validation pass rate ────────────────────────────────────────
-  const passRate = computePassRate(feature.validationHistory);
-  if (passRate !== null && passRate < minPassRate) {
-    blockers.push({
-      type: 'low_pass_rate',
-      current: passRate,
-      required: minPassRate,
-    });
-  }
-
-  // ── Check 4: Trust level ─────────────────────────────────────────────────
-  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, don't add blocker
-  }
-
-  return {
-    eligible: blockers.length === 0,
-    blockers,
-    currentPhase,
-    nextPhase,
-    passRate,
-  };
-}

package/src/lib/threads/thread-coordinator.js

@@ -1,238 +0,0 @@
-/**
- * Thread Coordinator — Dependency analysis and wait strategies
- *
- * Parses tasks.json dependency graphs and identifies:
- * - Tasks that can run in parallel (no dependencies on each other)
- * - Tasks that must run sequentially
- * - Circular dependencies
- *
- * Returns an execution plan: phases of parallel groups.
- *
- * Example output:
- *   Phase 1 (parallel): [T001, T002, T005]  ← no dependencies
- *   Phase 2 (parallel): [T003, T004]         ← depend only on phase 1
- *   Phase 3 (sequential): [T006]             ← depends on both T003, T004
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-// ============================================================================
-// Dependency Analysis
-// ============================================================================
-
-/**
- * Build a dependency graph from an in-memory task array
- * @param {Array} tasks - Array of { id, dependencies: [] } task objects
- * @returns {Object} { nodes: Map<id, task>, edges: Map<id, Set<depId>>, tasks }
- */
-export function buildGraph(tasks) {
-  const nodes = new Map();
-  const edges = new Map();
-
-  for (const task of tasks) {
-    nodes.set(task.id, task);
-    edges.set(task.id, new Set(task.dependencies || []));
-  }
-
-  return { nodes, edges, tasks };
-}
-
-/**
- * Parse tasks.json and build a dependency graph
- * @param {string} feature - Feature name
- * @returns {Object} { nodes: Map<id, task>, edges: Map<id, Set<depId>> }
- */
-export function analyzeDependencies(feature) {
-  const tasksPath = join(process.cwd(), `.morph/features/${feature}/tasks.json`);
-
-  if (!existsSync(tasksPath)) {
-    throw new Error(`tasks.json not found for feature: ${feature}`);
-  }
-
-  let tasksData;
-  try {
-    tasksData = JSON.parse(readFileSync(tasksPath, 'utf8'));
-  } catch (err) {
-    throw new Error(`Failed to parse tasks.json: ${err.message}`);
-  }
-
-  return buildGraph(tasksData.tasks || []);
-}
-
-/**
- * Identify tasks that can run in parallel (no dependencies between them)
- * @param {Object} graph - { nodes, edges } from buildGraph/analyzeDependencies
- * @returns {Array} Groups of task IDs that can run in parallel
- */
-export function identifyParallelizable(graph) {
-  const { nodes, edges } = graph;
-  const plan = planExecution(nodes, edges);
-  return plan.filter(group => group.length > 1);
-}
-
-/**
- * Identify tasks that must run sequentially
- * @param {Object} graph - { nodes, edges } from buildGraph/analyzeDependencies
- * @returns {Array} Task IDs that must run sequentially
- */
-export function identifySequential(graph) {
-  const { nodes, edges } = graph;
-  const plan = planExecution(nodes, edges);
-  return plan.filter(group => group.length === 1).flat();
-}
-
-/**
- * Detect circular dependencies in the task graph
- * @param {Map} nodes - Task nodes
- * @param {Map} edges - Dependency edges
- * @returns {Array} Array of circular dependency chains, or [] if none
- */
-export function detectCircular(nodes, edges) {
-  const cycles = [];
-  const visited = new Set();
-  const recursionStack = new Set();
-
-  function dfs(nodeId, path) {
-    visited.add(nodeId);
-    recursionStack.add(nodeId);
-
-    for (const dep of (edges.get(nodeId) || [])) {
-      if (!nodes.has(dep)) continue;
-
-      if (!visited.has(dep)) {
-        dfs(dep, [...path, nodeId]);
-      } else if (recursionStack.has(dep)) {
-        // Found a cycle
-        const cycleStart = path.indexOf(dep);
-        const cycle = cycleStart >= 0
-          ? [...path.slice(cycleStart), nodeId, dep]
-          : [...path, nodeId, dep];
-        cycles.push(cycle);
-      }
-    }
-
-    recursionStack.delete(nodeId);
-  }
-
-  for (const nodeId of nodes.keys()) {
-    if (!visited.has(nodeId)) {
-      dfs(nodeId, []);
-    }
-  }
-
-  return cycles;
-}
-
-/**
- * Plan execution: return phases of parallel task groups
- * @param {Map} nodes - Task nodes
- * @param {Map} edges - Dependency edges
- * @returns {Array} Array of phases, each phase is an array of task IDs
- *
- * Algorithm: Kahn's topological sort, grouping by "wave"
- */
-export function planExecution(nodes, edges) {
-  // Check for cycles first
-  const cycles = detectCircular(nodes, edges);
-  if (cycles.length > 0) {
-    throw new Error(
-      `Circular dependencies detected: ${cycles.map(c => c.join(' → ')).join('; ')}`
-    );
-  }
-
-  // Build reverse edges (dependents)
-  const inDegree = new Map();
-  const dependents = new Map(); // id → Set of task IDs that depend on it
-
-  for (const [id] of nodes) {
-    inDegree.set(id, 0);
-    dependents.set(id, new Set());
-  }
-
-  for (const [id, deps] of edges) {
-    for (const dep of deps) {
-      if (!inDegree.has(dep)) continue;
-      inDegree.set(id, (inDegree.get(id) || 0) + 1);
-      dependents.get(dep).add(id);
-    }
-  }
-
-  // Correct in-degree: count only deps that exist in nodes
-  for (const [id, deps] of edges) {
-    let count = 0;
-    for (const dep of deps) {
-      if (nodes.has(dep)) count++;
-    }
-    inDegree.set(id, count);
-  }
-
-  const phases = [];
-  const remaining = new Set(nodes.keys());
-
-  while (remaining.size > 0) {
-    // Find all nodes with no unsatisfied dependencies
-    const ready = [...remaining].filter(id => {
-      const deps = edges.get(id) || new Set();
-      return [...deps].every(dep => !remaining.has(dep));
-    });
-
-    if (ready.length === 0 && remaining.size > 0) {
-      // Shouldn't happen if no cycles, but safeguard
-      throw new Error(`Execution plan stalled with ${remaining.size} remaining tasks: ${[...remaining].join(', ')}`);
-    }
-
-    phases.push(ready);
-    for (const id of ready) {
-      remaining.delete(id);
-    }
-  }
-
-  return phases;
-}
-
-// ============================================================================
-// Full Analysis
-// ============================================================================
-
-/**
- * Get full parallel execution plan for a feature
- * @param {string} feature - Feature name
- * @returns {Object} Execution plan with phases, parallelizable groups, and stats
- */
-export function getExecutionPlan(feature) {
-  const { nodes, edges, tasks } = analyzeDependencies(feature);
-
-  const cycles = detectCircular(nodes, edges);
-  if (cycles.length > 0) {
-    return {
-      feature,
-      valid: false,
-      cycles,
-      error: `Circular dependencies found: ${cycles.map(c => c.join(' → ')).join('; ')}`
-    };
-  }
-
-  const phases = planExecution(nodes, edges);
-  const parallelPhases = phases.filter(p => p.length > 1);
-  const totalParallelizable = parallelPhases.reduce((sum, p) => sum + p.length, 0);
-
-  return {
-    feature,
-    valid: true,
-    totalTasks: tasks.length,
-    phases: phases.map((group, i) => ({
-      phase: i + 1,
-      tasks: group,
-      canRunParallel: group.length > 1,
-      count: group.length
-    })),
-    stats: {
-      totalPhases: phases.length,
-      parallelPhases: parallelPhases.length,
-      parallelizableTasks: totalParallelizable,
-      sequentialTasks: tasks.length - totalParallelizable,
-      parallelizationRatio: Math.round(totalParallelizable / Math.max(tasks.length, 1) * 100)
-    }
-  };
-}