@polymorphism-tech/morph-spec 7.9.4 → 8.1.0

package/framework/templates/meta-prompts/parallel-workers/parallel-coordinator.md

@@ -1,113 +0,0 @@
-# Parallel Coordinator — {{AGENT_ID}}
-
-You are the **Parallel Coordinator** overseeing a P-Thread execution session.
-
-## Your Identity
-- Agent: {{AGENT_ID}}
-- Role: Parallel Coordinator (Orchestrator Tier)
-- Session ID: {{SESSION_ID}}
-- Feature: {{FEATURE_NAME}}
-
-## Your Mission
-Coordinate {{WORKER_COUNT}} parallel workers executing concurrently, then merge and validate their outputs.
-
-## Workers Under Coordination
-
-{{WORKERS}}
-
-Each worker has isolated file scope — no cross-worker dependencies during execution.
-
-## Execution Plan
-
-### Phase 1: Pre-Execution Validation
-Before spawning workers, verify:
-- [ ] All workers have non-overlapping file scopes
-- [ ] No circular dependencies between workers
-- [ ] Shared read files are available (spec.md, standards, contracts)
-- [ ] State is set to `parallel-executing`
-
-### Phase 2: Spawn Workers
-Spawn all workers concurrently using Task tool:
-```
-Task tool × {{WORKER_COUNT}} simultaneous invocations
-Strategy: {{PARALLEL_STRATEGY}}
-Max concurrent: {{MAX_CONCURRENT}}
-```
-
-### Phase 3: Wait for Completion
-Monitor workers — do NOT proceed until all report back (or timeout):
-- Success: Worker returns COMPLETE report
-- Partial: Worker returns PARTIAL — merge what's available
-- Timeout: After {{TIMEOUT_MINUTES}} minutes, mark as PARTIAL and proceed
-- Failed: Document failure, continue with successful workers
-
-### Phase 4: Merge Results
-After all workers complete:
-1. Collect all "Files Created" from worker reports
-2. Check for conflicts (same filename from different workers)
-3. If conflicts: Apply `{{MERGE_STRATEGY}}` strategy
-4. Update state with combined file list
-
-### Phase 5: Integration Validation
-Run cross-worker validation:
-```bash
-morph-spec validate architecture --feature={{FEATURE_NAME}}
-morph-spec validate security --feature={{FEATURE_NAME}}
-```
-
-Check that:
-- Files from all workers are consistent (same types, interfaces, naming)
-- No duplicate functionality across workers
-- Integration points (shared interfaces, types) are compatible
-
-## Spec Summary
-{{SPEC_SUMMARY}}
-
-## Merge Strategies
-
-| Strategy | When to Use |
-|----------|-------------|
-| `last-wins` | Non-overlapping files (default — workers shouldn't overlap) |
-| `manual-review` | Conflicting implementations of same file |
-| `best-score` | Multiple implementations of same logic (use checkpoint scores) |
-
-## Your Tasks
-
-### Pre-Spawn
-{{PRE_SPAWN_TASKS}}
-
-### Post-Merge
-{{POST_MERGE_TASKS}}
-
-## Completion Report
-
-When all workers are merged and validated:
-
-```
-COORDINATOR REPORT
-Session: {{SESSION_ID}}
-Feature: {{FEATURE_NAME}}
-Status: [SUCCESS | PARTIAL | FAILED]
-
-Worker Results:
-{{#each WORKERS}}
-  - {{this.agent}}: [COMPLETE | PARTIAL | FAILED] — {{this.filesCreated}} files
-{{/each}}
-
-Total Files Created: X
-Conflicts Resolved: Y
-Integration Validation: [PASSED | FAILED]
-
-Final File List:
-- [all files from all workers]
-
-Next Steps:
-- [what the main thread should do with these outputs]
-```
-
-## Constraints
-{{CONSTRAINTS}}
-
-- Never modify worker outputs without documenting the change
-- If merge conflict cannot be auto-resolved, escalate to user
-- Coordinator does NOT implement features — only orchestrates and validates

package/framework/templates/meta-prompts/parallel-workers/parallel-worker.md

@@ -1,80 +0,0 @@
-# Parallel Worker — {{AGENT_ID}}
-
-You are a **Parallel Worker** (P-Thread) executing concurrently with other agents.
-
-## Your Identity
-- Agent: {{AGENT_ID}}
-- Role: Parallel Worker (P-Thread)
-- Thread ID: {{THREAD_ID}}
-- Feature: {{FEATURE_NAME}}
-
-## Your Isolated Mission
-{{MISSION}}
-
-## CRITICAL: Isolation Rules
-
-You are running **concurrently** with other workers. To avoid conflicts:
-
-1. **Write ONLY to your assigned files** (listed under Deliverables)
-2. **Do NOT modify shared files** (state.json, agents.json, config files)
-3. **Do NOT depend on output from other parallel workers** (your tasks are self-contained)
-4. **Read from shared files is OK** (spec.md, standards, contracts)
-5. **Report blockers** instead of waiting for another worker
-
-## Your Assigned Scope
-{{SCOPE}}
-
-Files you OWN (safe to create/modify):
-{{DELIVERABLES}}
-
-Files you can READ (shared, do not modify):
-- `.morph/features/{{FEATURE_NAME}}/2-design/spec.md`
-- `framework/standards/` (all)
-- `.morph/features/{{FEATURE_NAME}}/2-design/contracts.*`
-
-## Spec Summary
-{{SPEC_SUMMARY}}
-
-## Standards to Follow
-{{STANDARDS}}
-
-## Your Tasks (Isolated)
-{{TASKS}}
-
-These tasks are **independent** — no cross-worker dependencies. If you encounter a dependency, document it and skip.
-
-## How to Work
-1. Verify your file scope — check you're not touching shared files
-2. Implement tasks in order within your scope
-3. After every 3 tasks, persist completed tasks to `tasks.json` (`status`/`outputs`/`notes` only) and run the checkpoint
-4. If blocked by missing dependency, note it in your report and continue
-5. Complete ALL tasks in your scope before reporting back
-
-## Completion Report
-When done, provide a structured report:
-
-```
-PARALLEL WORKER REPORT
-Thread: {{THREAD_ID}}
-Agent: {{AGENT_ID}}
-Status: [COMPLETE | PARTIAL | BLOCKED]
-
-Files Created:
-- [list each file with brief description]
-
-Files Modified:
-- [list each file with what changed]
-
-Tasks Completed: X/Y
-Tasks Skipped: [list with reason]
-
-Blockers:
-- [any dependencies or conflicts encountered]
-
-Checkpoints: [PASSED | FAILED | N/A]
-```
-
-## Important
-- Do NOT wait for other workers — complete what you can
-- Do NOT create files outside your assigned scope
-- Coordinator will merge results after all workers complete

package/src/lib/tasks/wave-resolver.js

@@ -1,353 +0,0 @@
-/**
- * @fileoverview Wave Resolver — Dependency-aware task grouping into execution waves.
- *
- * Pure algorithm module (no I/O, no state access). Takes parsed task lists and
- * returns wave assignments. Tasks within a wave have no interdependencies and
- * don't touch the same files, so they can safely run in parallel.
- *
- * @module wave-resolver
- */
-
-/**
- * Validate that all dependency references point to existing task IDs.
- *
- * @param {Array<{id: string, dependencies: string[]}>} taskList
- * @returns {{ valid: boolean, errors: string[] }}
- */
-export function validateDependencies(taskList) {
-  const ids = new Set(taskList.map(t => t.id));
-  const errors = [];
-
-  for (const task of taskList) {
-    for (const dep of task.dependencies || []) {
-      if (dep === task.id) {
-        errors.push(`${task.id} depends on itself`);
-      } else if (!ids.has(dep)) {
-        errors.push(`${task.id} depends on ${dep} which does not exist`);
-      }
-    }
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-/**
- * Detect circular dependencies using Kahn's algorithm.
- * Returns the cycle path if found, or null if acyclic.
- *
- * @param {Array<{id: string, dependencies: string[]}>} taskList
- * @returns {{ hasCycle: boolean, cycle: string[]|null }}
- */
-export function detectCircularDeps(taskList) {
-  const ids = new Set(taskList.map(t => t.id));
-  const inDegree = new Map();
-  const adjacency = new Map(); // dependency → dependents
-
-  for (const task of taskList) {
-    inDegree.set(task.id, 0);
-    if (!adjacency.has(task.id)) adjacency.set(task.id, []);
-  }
-
-  for (const task of taskList) {
-    for (const dep of task.dependencies || []) {
-      if (!ids.has(dep)) continue; // skip invalid refs (caught by validateDependencies)
-      inDegree.set(task.id, (inDegree.get(task.id) || 0) + 1);
-      if (!adjacency.has(dep)) adjacency.set(dep, []);
-      adjacency.get(dep).push(task.id);
-    }
-  }
-
-  // BFS: process zero-in-degree nodes
-  const queue = [];
-  for (const [id, deg] of inDegree) {
-    if (deg === 0) queue.push(id);
-  }
-
-  const processed = new Set();
-  while (queue.length > 0) {
-    const node = queue.shift();
-    processed.add(node);
-    for (const dependent of adjacency.get(node) || []) {
-      inDegree.set(dependent, inDegree.get(dependent) - 1);
-      if (inDegree.get(dependent) === 0) queue.push(dependent);
-    }
-  }
-
-  if (processed.size === taskList.length) {
-    return { hasCycle: false, cycle: null };
-  }
-
-  // Extract cycle from unprocessed nodes via DFS
-  const unprocessed = taskList.filter(t => !processed.has(t.id));
-  const depMap = new Map(taskList.map(t => [t.id, t.dependencies || []]));
-  const visiting = new Set();
-  const path = [];
-
-  function dfs(nodeId) {
-    if (visiting.has(nodeId)) {
-      const cycleStart = path.indexOf(nodeId);
-      return path.slice(cycleStart).concat(nodeId);
-    }
-    if (processed.has(nodeId)) return null;
-
-    visiting.add(nodeId);
-    path.push(nodeId);
-
-    for (const dep of depMap.get(nodeId) || []) {
-      if (!ids.has(dep)) continue;
-      const cycle = dfs(dep);
-      if (cycle) return cycle;
-    }
-
-    visiting.delete(nodeId);
-    path.pop();
-    return null;
-  }
-
-  for (const task of unprocessed) {
-    const cycle = dfs(task.id);
-    if (cycle) return { hasCycle: true, cycle };
-  }
-
-  // Fallback: cycle exists but couldn't extract path
-  return { hasCycle: true, cycle: unprocessed.map(t => t.id) };
-}
-
-/**
- * Assign a wave level to each task via topological sort.
- * Tasks with no dependencies go to wave 0. Tasks whose dependencies
- * are all in wave N go to wave N+1.
- *
- * @param {Array<{id: string, dependencies: string[], status?: string}>} taskList
- * @param {{ includeCompleted?: boolean }} options
- * @returns {Array<{ waveIndex: number, tasks: string[] }>}
- */
-export function resolveWaves(taskList, options = {}) {
-  // Filter tasks
-  const activeTasks = options.includeCompleted
-    ? taskList
-    : taskList.filter(t => t.status !== 'completed' && t.status !== 'expanded');
-
-  if (activeTasks.length === 0) return [];
-
-  const ids = new Set(activeTasks.map(t => t.id));
-  const completedIds = new Set(
-    taskList.filter(t => t.status === 'completed' || t.status === 'expanded').map(t => t.id)
-  );
-
-  // Assign levels via BFS
-  const level = new Map();
-  const inDegree = new Map();
-  const adjacency = new Map();
-
-  for (const task of activeTasks) {
-    inDegree.set(task.id, 0);
-    adjacency.set(task.id, []);
-    level.set(task.id, 0);
-  }
-
-  for (const task of activeTasks) {
-    for (const dep of task.dependencies || []) {
-      if (!ids.has(dep)) continue; // dep is completed or doesn't exist → satisfied
-      inDegree.set(task.id, inDegree.get(task.id) + 1);
-      adjacency.get(dep).push(task.id);
-    }
-  }
-
-  // BFS with level tracking
-  const queue = [];
-  for (const [id, deg] of inDegree) {
-    if (deg === 0) {
-      queue.push(id);
-      level.set(id, 0);
-    }
-  }
-
-  while (queue.length > 0) {
-    const node = queue.shift();
-    const nodeLevel = level.get(node);
-
-    for (const dependent of adjacency.get(node)) {
-      const newDeg = inDegree.get(dependent) - 1;
-      inDegree.set(dependent, newDeg);
-
-      // Level = max of all dependency levels + 1
-      const candidateLevel = nodeLevel + 1;
-      if (candidateLevel > level.get(dependent)) {
-        level.set(dependent, candidateLevel);
-      }
-
-      if (newDeg === 0) queue.push(dependent);
-    }
-  }
-
-  // Group by level
-  const waveMap = new Map();
-  for (const [id, lvl] of level) {
-    if (!waveMap.has(lvl)) waveMap.set(lvl, []);
-    waveMap.get(lvl).push(id);
-  }
-
-  // Sort waves and task IDs within waves
-  const waves = [...waveMap.entries()]
-    .sort((a, b) => a[0] - b[0])
-    .map(([idx, tasks]) => ({
-      waveIndex: idx,
-      tasks: tasks.sort()
-    }));
-
-  return waves;
-}
-
-/**
- * Parse file paths from a task's deliverables/steps section.
- * Looks for backtick-wrapped paths in deliverable lines.
- *
- * @param {string} taskBlock - The markdown block for a single task
- * @returns {string[]} Array of file paths (deduplicated, normalized to forward slashes)
- */
-export function parseTaskFiles(taskBlock) {
-  const files = new Set();
-
-  // Match: - [ ] Create/Update/Modify/Delete: `path/to/file`
-  const deliverableRe = /- \[[ x]\]\s*(?:Create|Update|Modify|Delete|Add|Edit|Remove):\s*`([^`]+)`/gi;
-  let match;
-  while ((match = deliverableRe.exec(taskBlock)) !== null) {
-    files.add(match[1].replace(/\\/g, '/'));
-  }
-
-  // Also match: **Files:** `path1`, `path2`
-  const filesFieldRe = /\*\*Files?:\*\*\s*(.+)/i;
-  const filesMatch = filesFieldRe.exec(taskBlock);
-  if (filesMatch) {
-    const backtickRe = /`([^`]+)`/g;
-    let fMatch;
-    while ((fMatch = backtickRe.exec(filesMatch[1])) !== null) {
-      files.add(fMatch[1].replace(/\\/g, '/'));
-    }
-  }
-
-  return [...files];
-}
-
-/**
- * Detect file conflicts within each wave and redistribute conflicting
- * tasks to later waves.
- *
- * @param {Array<{ waveIndex: number, tasks: string[] }>} waves
- * @param {Map<string, string[]>} taskFileMap - taskId → file paths
- * @returns {Array<{ waveIndex: number, tasks: string[] }>}
- */
-export function resolveFileConflicts(waves, taskFileMap) {
-  if (!taskFileMap || taskFileMap.size === 0) return waves;
-
-  // Deep copy to avoid mutation
-  let result = waves.map(w => ({ waveIndex: w.waveIndex, tasks: [...w.tasks] }));
-  const maxIterations = waves.reduce((sum, w) => sum + w.tasks.length, 0) + 1;
-
-  for (let iter = 0; iter < maxIterations; iter++) {
-    let changed = false;
-
-    for (let wi = 0; wi < result.length; wi++) {
-      const wave = result[wi];
-      const fileOwner = new Map(); // file → first taskId
-      const toDefer = [];
-
-      for (const taskId of wave.tasks) {
-        const files = taskFileMap.get(taskId) || [];
-        let hasConflict = false;
-
-        for (const file of files) {
-          if (fileOwner.has(file)) {
-            hasConflict = true;
-            break;
-          }
-        }
-
-        if (hasConflict) {
-          toDefer.push(taskId);
-        } else {
-          for (const file of files) {
-            fileOwner.set(file, taskId);
-          }
-        }
-      }
-
-      if (toDefer.length > 0) {
-        changed = true;
-        wave.tasks = wave.tasks.filter(t => !toDefer.includes(t));
-
-        // Push to next wave or create one
-        const nextWi = wi + 1;
-        if (nextWi < result.length) {
-          result[nextWi].tasks.push(...toDefer);
-          result[nextWi].tasks.sort();
-        } else {
-          result.push({ waveIndex: result.length, tasks: toDefer.sort() });
-        }
-      }
-    }
-
-    if (!changed) break;
-  }
-
-  // Remove empty waves and re-index
-  result = result.filter(w => w.tasks.length > 0);
-  result.forEach((w, i) => { w.waveIndex = i; });
-
-  return result;
-}
-
-/**
- * Full resolution pipeline: validate → detect cycles → resolve waves → resolve conflicts.
- *
- * @param {Array<{id: string, title?: string, status?: string, dependencies: string[]}>} taskList
- * @param {Map<string, string[]>} taskFileMap - Optional file map for conflict detection
- * @returns {{ waves: Array<{ waveIndex: number, tasks: string[] }>, errors: string[], warnings: string[] }}
- */
-export function resolveWavePlan(taskList, taskFileMap = new Map()) {
-  const errors = [];
-  const warnings = [];
-
-  if (!taskList || taskList.length === 0) {
-    return { waves: [], errors: [], warnings: ['No tasks to resolve'] };
-  }
-
-  // Step 1: Validate dependencies
-  const validation = validateDependencies(taskList);
-  if (!validation.valid) {
-    errors.push(...validation.errors);
-    return { waves: [], errors, warnings };
-  }
-
-  // Step 2: Detect circular dependencies
-  const cycleCheck = detectCircularDeps(taskList);
-  if (cycleCheck.hasCycle) {
-    errors.push(`Circular dependency detected: ${cycleCheck.cycle.join(' → ')}`);
-    return { waves: [], errors, warnings };
-  }
-
-  // Step 3: Resolve waves from dependencies
-  let waves = resolveWaves(taskList);
-
-  // Step 4: Resolve file conflicts
-  if (taskFileMap.size > 0) {
-    const before = waves.map(w => w.tasks.length);
-    waves = resolveFileConflicts(waves, taskFileMap);
-    const after = waves.map(w => w.tasks.length);
-
-    // Report redistributions
-    if (JSON.stringify(before) !== JSON.stringify(after)) {
-      warnings.push('Some tasks were moved to later waves due to file conflicts');
-    }
-  }
-
-  // Report skipped tasks
-  const activeTasks = taskList.filter(t => t.status !== 'completed' && t.status !== 'expanded');
-  const skipped = taskList.length - activeTasks.length;
-  if (skipped > 0) {
-    warnings.push(`${skipped} completed/expanded task(s) excluded from wave plan`);
-  }
-
-  return { waves, errors, warnings };
-}