mindforge-cc 8.2.0 → 10.0.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/wave-engine.test.js

@@ -1,336 +0,0 @@
-/**
- * MindForge Wave Engine Tests
- * Tests: dependency parsing, wave grouping, and execution planning
- * Run: node tests/wave-engine.test.js
- */
-
-const assert = require('assert');
-
-let passed = 0;
-let failed = 0;
-
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ✅ ${name}`);
-    passed++;
-  } catch (err) {
-    console.error(`  ❌ ${name}`);
-    console.error(`     ${err.message}`);
-    failed++;
-  }
-}
-
-// ── Simulate the dependency parser and wave grouper ───────────────────────────
-
-/**
- * Simulates parsing a PLAN file's dependency field
- * In real execution, this reads from the actual XML PLAN files
- */
-function parseDependencies(depString) {
-  if (!depString || depString.trim().toLowerCase() === 'none') return [];
-  return depString.split(',').map(d => d.trim()).filter(Boolean);
-}
-
-/**
- * Simulates the wave grouping algorithm (Kahn's topological sort)
- * Input: { "01": { dependsOn: [] }, "02": { dependsOn: ["01"] }, ... }
- * Output: [["01"], ["02"], ...]
- */
-function groupIntoWaves(graph) {
-  const remaining = new Set(Object.keys(graph));
-  const completed = new Set();
-  const waves = [];
-
-  while (remaining.size > 0) {
-    const wave = [];
-    for (const id of remaining) {
-      const deps = graph[id].dependsOn;
-      if (deps.every(d => completed.has(d))) {
-        wave.push(id);
-      }
-    }
-
-    if (wave.length === 0 && remaining.size > 0) {
-      throw new Error(`Circular dependency detected among: ${[...remaining].join(', ')}`);
-    }
-
-    waves.push(wave.sort());
-    wave.forEach(id => { completed.add(id); remaining.delete(id); });
-  }
-
-  return waves;
-}
-
-/**
- * Detects circular dependencies
- */
-function hasCircularDependency(graph) {
-  try {
-    groupIntoWaves(graph);
-    return false;
-  } catch {
-    return true;
-  }
-}
-
-/**
- * Detects file conflicts between plans
- */
-function findFileConflicts(plans) {
-  const fileMap = {};
-  const conflicts = [];
-
-  plans.forEach(({ id, files }) => {
-    files.forEach(file => {
-      if (fileMap[file]) {
-        conflicts.push({ file, plans: [fileMap[file], id] });
-      } else {
-        fileMap[file] = id;
-      }
-    });
-  });
-
-  return conflicts;
-}
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-console.log('\nMindForge Day 2 — Wave Engine Tests\n');
-
-console.log('Dependency parsing:');
-
-test('parses "none" as empty dependencies', () => {
-  assert.deepStrictEqual(parseDependencies('none'), []);
-  assert.deepStrictEqual(parseDependencies('None'), []);
-  assert.deepStrictEqual(parseDependencies('NONE'), []);
-});
-
-test('parses single dependency', () => {
-  assert.deepStrictEqual(parseDependencies('01'), ['01']);
-});
-
-test('parses multiple dependencies', () => {
-  assert.deepStrictEqual(parseDependencies('01, 02, 03'), ['01', '02', '03']);
-});
-
-test('handles whitespace in dependency list', () => {
-  assert.deepStrictEqual(parseDependencies('01,02,  03'), ['01', '02', '03']);
-});
-
-test('parses empty string as no dependencies', () => {
-  assert.deepStrictEqual(parseDependencies(''), []);
-});
-
-console.log('\nWave grouping algorithm:');
-
-test('single task with no dependencies → 1 wave', () => {
-  const graph = { '01': { dependsOn: [] } };
-  const waves = groupIntoWaves(graph);
-  assert.deepStrictEqual(waves, [['01']]);
-});
-
-test('two independent tasks → 1 wave with both', () => {
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: [] },
-  };
-  const waves = groupIntoWaves(graph);
-  assert.strictEqual(waves.length, 1);
-  assert.deepStrictEqual(waves[0].sort(), ['01', '02']);
-});
-
-test('sequential dependency chain → 3 waves, 1 task each', () => {
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: ['01'] },
-    '03': { dependsOn: ['02'] },
-  };
-  const waves = groupIntoWaves(graph);
-  assert.strictEqual(waves.length, 3);
-  assert.deepStrictEqual(waves[0], ['01']);
-  assert.deepStrictEqual(waves[1], ['02']);
-  assert.deepStrictEqual(waves[2], ['03']);
-});
-
-test('diamond dependency (fan-out then fan-in)', () => {
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: ['01'] },
-    '03': { dependsOn: ['01'] },
-    '04': { dependsOn: ['02', '03'] },
-  };
-  const waves = groupIntoWaves(graph);
-  assert.strictEqual(waves.length, 3);
-  assert.deepStrictEqual(waves[0], ['01']);
-  assert.deepStrictEqual(waves[1].sort(), ['02', '03']);
-  assert.deepStrictEqual(waves[2], ['04']);
-});
-
-test('5-plan realistic example (user model → api → checkout)', () => {
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: [] },
-    '03': { dependsOn: ['01'] },
-    '04': { dependsOn: ['02'] },
-    '05': { dependsOn: ['03', '04'] },
-  };
-  const waves = groupIntoWaves(graph);
-  assert.strictEqual(waves.length, 3);
-  assert.deepStrictEqual(waves[0].sort(), ['01', '02']);
-  assert.deepStrictEqual(waves[1].sort(), ['03', '04']);
-  assert.deepStrictEqual(waves[2], ['05']);
-});
-
-console.log('\nCircular dependency detection:');
-
-test('detects direct circular dependency (A → B → A)', () => {
-  const graph = {
-    '01': { dependsOn: ['02'] },
-    '02': { dependsOn: ['01'] },
-  };
-  assert.strictEqual(hasCircularDependency(graph), true);
-});
-
-test('detects indirect circular dependency (A → B → C → A)', () => {
-  const graph = {
-    '01': { dependsOn: ['03'] },
-    '02': { dependsOn: ['01'] },
-    '03': { dependsOn: ['02'] },
-  };
-  assert.strictEqual(hasCircularDependency(graph), true);
-});
-
-test('does not false-positive on valid DAG', () => {
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: ['01'] },
-    '03': { dependsOn: ['01'] },
-    '04': { dependsOn: ['02', '03'] },
-  };
-  assert.strictEqual(hasCircularDependency(graph), false);
-});
-
-console.log('\nFile conflict detection:');
-
-test('detects conflict when two plans modify the same file', () => {
-  const plans = [
-    { id: '01', files: ['src/models/user.ts', 'src/models/user.test.ts'] },
-    { id: '02', files: ['src/models/product.ts'] },
-    { id: '03', files: ['src/models/user.ts'] },
-  ];
-  const conflicts = findFileConflicts(plans);
-  assert.strictEqual(conflicts.length, 1);
-  assert.strictEqual(conflicts[0].file, 'src/models/user.ts');
-  assert.deepStrictEqual(conflicts[0].plans.sort(), ['01', '03']);
-});
-
-test('no conflicts when all plans touch different files', () => {
-  const plans = [
-    { id: '01', files: ['src/models/user.ts'] },
-    { id: '02', files: ['src/models/product.ts'] },
-    { id: '03', files: ['src/api/orders.ts'] },
-  ];
-  const conflicts = findFileConflicts(plans);
-  assert.strictEqual(conflicts.length, 0);
-});
-
-console.log('\nAdditional edge cases:');
-
-test('handles empty graph (zero plans)', () => {
-  const waves = groupIntoWaves({});
-  assert.deepStrictEqual(waves, []);
-});
-
-test('detects self-referencing dependency (plan depends on itself)', () => {
-  const graph = { '01': { dependsOn: ['01'] } };
-  assert.strictEqual(hasCircularDependency(graph), true);
-});
-
-test('three plans all touching the same file — all conflict', () => {
-  const plans = [
-    { id: '01', files: ['src/shared.ts'] },
-    { id: '02', files: ['src/shared.ts'] },
-    { id: '03', files: ['src/shared.ts'] },
-  ];
-  const conflicts = findFileConflicts(plans);
-  assert.ok(conflicts.length >= 2, `Expected >= 2 conflicts, got ${conflicts.length}`);
-});
-
-test('6-plan complex graph groups correctly', () => {
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: [] },
-    '03': { dependsOn: [] },
-    '04': { dependsOn: ['01', '02'] },
-    '05': { dependsOn: ['02', '03'] },
-    '06': { dependsOn: ['04', '05'] },
-  };
-  const waves = groupIntoWaves(graph);
-  assert.strictEqual(waves.length, 3);
-  assert.deepStrictEqual(waves[0].sort(), ['01', '02', '03']);
-  assert.deepStrictEqual(waves[1].sort(), ['04', '05']);
-  assert.deepStrictEqual(waves[2], ['06']);
-});
-
-test('single linear chain of 4 plans → 4 waves', () => {
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: ['01'] },
-    '03': { dependsOn: ['02'] },
-    '04': { dependsOn: ['03'] },
-  };
-  const waves = groupIntoWaves(graph);
-  assert.strictEqual(waves.length, 4);
-  waves.forEach((wave, i) => {
-    const expectedId = String(i + 1).padStart(2, '0');
-    assert.deepStrictEqual(wave, [expectedId]);
-  });
-});
-
-test('wave executor stops on first failure — does not cascade', () => {
-  // Simulates: Wave 1 has 3 tasks. Task 02 fails.
-  // Expected: tasks 01 and 03 may run, but Wave 2 must NOT start.
-  const executionLog = [];
-
-  function simulateWaveExecution(graph, failingPlan) {
-    const waves = groupIntoWaves(graph);
-    let phaseFailed = false;
-
-    for (const wave of waves) {
-      if (phaseFailed) break;
-      for (const planId of wave) {
-        if (planId === failingPlan) {
-          executionLog.push({ plan: planId, status: 'failed' });
-          phaseFailed = true;
-        } else if (!phaseFailed) {
-          executionLog.push({ plan: planId, status: 'completed' });
-        }
-      }
-    }
-    return { phaseFailed, executionLog };
-  }
-
-  const graph = {
-    '01': { dependsOn: [] },
-    '02': { dependsOn: [] },
-    '03': { dependsOn: [] },
-    '04': { dependsOn: ['01', '03'] },
-  };
-
-  const result = simulateWaveExecution(graph, '02');
-  assert.strictEqual(result.phaseFailed, true);
-  const plan04Executed = result.executionLog.some(e => e.plan === '04');
-  assert.strictEqual(plan04Executed, false, 'Plan 04 should not execute after wave failure');
-});
-
-// ── Results ───────────────────────────────────────────────────────────────────
-console.log(`\n${'─'.repeat(50)}`);
-console.log(`Results: ${passed} passed, ${failed} failed`);
-
-if (failed > 0) {
-  console.error(`\n❌ ${failed} test(s) failed.\n`);
-  process.exit(1);
-} else {
-  console.log('\n✅ All wave engine tests passed.\n');
-}

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/ztai-enterprise.test.js

@@ -1,103 +0,0 @@
-/**
- * MindForge ZTAI 'Enterprise Mode' Verification Suite
- * v4.2.5 — Hardened Verification
- */
-
-const ztai = require('../bin/governance/ztai-manager');
-const ZTAIArchiver = require('../bin/governance/ztai-archiver');
-const fs = require('node:fs/promises');
-const path = require('node:path');
-
-async function verifyEnterpriseMode() {
-  console.log('--- MindForge ZTAI Enterprise Mode Verification ---');
-
-  try {
-    // 1. Tiered Registration & Provider Selection
-    const architectDid = await ztai.registerAgent('architect', 3);
-    const analystDid = await ztai.registerAgent('analyst', 1);
-
-    const architectInfo = ztai.getAgent(architectDid);
-    const analystInfo = ztai.getAgent(analystDid);
-
-    console.log('[Test 1] Tiered Registration:');
-    console.log(` - Architect DID: ${architectDid} (Provider: ${architectInfo.providerType}, Tier: ${architectInfo.tier})`);
-    console.log(` - Analyst DID: ${analystDid} (Provider: ${analystInfo.providerType}, Tier: ${analystInfo.tier})`);
-
-    if (architectInfo.providerType !== 'enclave' || analystInfo.providerType !== 'local') {
-      throw new Error('FAILED: Provider selection mismatch for tiers');
-    }
-    console.log(' ✅ Success');
-
-    // 2. Cross-Provider Signing
-    const data = 'Mission-critical architectural change: ADR-001';
-    const archSignature = await ztai.signData(architectDid, data);
-    const analystSignature = await ztai.signData(analystDid, data);
-
-    console.log('[Test 2] Cross-Provider Signing:');
-    console.log(` - Architect Signature (Enclave): ${archSignature.substring(0, 16)}...`);
-    console.log(` - Analyst Signature (Local): ${analystSignature.substring(0, 16)}...`);
-
-    const isArchValid = ztai.verifySignature(architectDid, data, archSignature);
-    const isAnalystValid = ztai.verifySignature(analystDid, data, analystSignature);
-
-    if (!isArchValid || !isAnalystValid) {
-      throw new Error('FAILED: Cross-provider signature verification failed');
-    }
-    console.log(' ✅ Success');
-
-    // 3. Audit Archiver & Manifest Generation
-    // Create a dummy audit log for testing
-    const auditDir = '.mindforge/audit';
-    const auditPath = path.join(auditDir, 'AUDIT.jsonl');
-    await fs.mkdir(auditDir, { recursive: true });
-    
-    const dummyEntries = [
-      { timestamp: new Date().toISOString(), event: 'spawn', did: architectDid, signature: archSignature },
-      { timestamp: new Date().toISOString(), event: 'plan', did: analystDid, signature: analystSignature }
-    ];
-    
-    await fs.writeFile(auditPath, dummyEntries.map(e => JSON.stringify(e)).join('\n'));
-
-    const archiver = new ZTAIArchiver(auditPath);
-    const manifest = await archiver.archiveAuditLog(architectDid);
-
-    console.log('[Test 3] Audit Archiver:');
-    console.log(` - Manifest Block: ${manifest.blockStart} to ${manifest.blockEnd}`);
-    console.log(` - Merkle Root: ${manifest.merkleRoot}`);
-    console.log(` - Manifest Signed by Architect: ${manifest.signature.substring(0, 16)}...`);
-
-    const { signature: manifestSig, ...manifestMetadata } = manifest;
-    const isManifestValid = ztai.verifySignature(architectDid, JSON.stringify(manifestMetadata), manifestSig);
-    if (!isManifestValid) {
-      throw new Error('FAILED: Manifest signature invalid');
-    }
-    console.log(' ✅ Success');
-
-    // 4. Key Rotation (Enclave)
-    console.log('[Test 4] Key Rotation (Enclave):');
-    const oldKey = architectInfo.publicKey;
-    await ztai.rotateKeys(architectDid);
-    const newKey = ztai.getAgent(architectDid).publicKey;
-
-    if (oldKey === newKey) {
-      throw new Error('FAILED: Enclave key rotation failed');
-    }
-    
-    // Sign with new rotated key
-    const newData = 'Post-rotation action';
-    const newSig = await ztai.signData(architectDid, newData);
-    if (!ztai.verifySignature(architectDid, newData, newSig)) {
-       throw new Error('FAILED: Signature verification failed after rotation');
-    }
-    console.log(' ✅ Success');
-
-    console.log('--- All ZTAI Enterprise Mode Tests Passed 🚀 ---');
-    process.exit(0);
-  } catch (err) {
-    console.error('--- ZTAI Verification Failed ❌ ---');
-    console.error(err.message);
-    process.exit(1);
-  }
-}
-
-verifyEnterpriseMode();

package/.mindforge/models/model-registry.md

@@ -1,48 +0,0 @@
-# MindForge v2 — Model Registry
-# Version: v2.0.0-alpha.3
-
-MindForge v2 uses a tiered multi-model architecture. Models are selected based on the task persona and difficulty tier.
-
-## 1. Primary Reasoning Tier (Tier 1)
-Used for complex architecture, planning, and high-stakes reasoning.
-
-- **Anthropic Claude 3.5 Opus** (`claude-3-opus-20240229`)
-  - Strengths: Deepest reasoning, highly reliable for planning.
-  - Persona mapping: `architect`, `planner`.
-  - Setting: `PLANNER_MODEL`.
-
-- **OpenAI GPT-4o** (`gpt-4o`)
-  - Strengths: Fast reasoning, excellent tool use, adversarial insight.
-  - Persona mapping: `reviewer`, `security-reviewer`.
-  - Setting: `REVIEWER_MODEL`.
-
-## 2. Execution Tier (Tier 2)
-Used for the bulk of code implementation and transformation tasks.
-
-- **Anthropic Claude 3.5 Sonnet** (`claude-3-5-sonnet-20240620`)
-  - Strengths: Balanced speed/quality, best-in-class coding.
-  - Persona mapping: `developer`, `qa-engineer`.
-  - Setting: `EXECUTOR_MODEL`.
-
-- **Google Gemini 1.5 Pro** (`gemini-1.5-pro`)
-  - Strengths: 1M context window, deep codebase research.
-  - Persona mapping: `research-agent`.
-  - Setting: `RESEARCH_MODEL`.
-
-## 3. High-Security/Privacy Tier (Tier 3)
-Used for tasks involving authentication, PII, or financial operations.
-
-- **Anthropic Claude 3.5 Opus** (`claude-3-opus-20240229`)
-  - Setting: `SECURITY_MODEL`.
-
-## 4. Utility/Quick Tier (Tier 4)
-Used for low-ambiguity tasks and micro-transformations.
-
-- **Anthropic Claude 3.5 Haiku** (`claude-3-5-haiku-20241022`)
-  - Setting: `QUICK_MODEL`.
-
-## 5. Fallback Chain
-If a primary model is unavailable (API key missing or 429), follow these defaults:
-1. `gpt-4o` → `claude-3-5-sonnet`
-2. `claude-3-opus` → `gpt-4o`
-3. `gemini-1.5-pro` → `claude-3-5-sonnet` (limited context)

package/.mindforge/models/model-router.md

@@ -1,30 +0,0 @@
-# MindForge v2 — Model Router
-# Version: v2.0.0-alpha.3
-
-## Routing Logic
-
-The MindForge router resolves which model to use at task dispatch time using this algorithm:
-
-1. **Check Persona:** Map the task `<persona>` to a setting key.
-   - `developer` → `EXECUTOR_MODEL`
-   - `architect` → `PLANNER_MODEL`
-   - `security-reviewer` → `SECURITY_MODEL`
-   - `qa-engineer` → `QA_MODEL`
-   - `research-agent` → `RESEARCH_MODEL`
-   - `debug-specialist` → `DEBUG_MODEL`
-   - `unknown` → `EXECUTOR_MODEL`
-
-2. **Check Tier Override:**
-   - If `tier == 3` (Security/Privacy), force `SECURITY_MODEL` regardless of persona.
-
-3. **Check Budget Bias:**
-   - If `difficulty < 2.0` and `MODEL_PREFER_CHEAP_BELOW_DIFFICULTY` is set:
-     - Use `QUICK_MODEL` instead of the resolved model.
-
-4. **Resolve Model ID:**
-   - Read the setting key from `MINDFORGE.md`.
-   - Use baked-in defaults if not present.
-
-5. **Verify Availability:**
-   - Check if matching `[PROVIDER]_API_KEY` is present in environment.
-   - If missing: Apply fallback chain from `model-registry.md`.

package/.mindforge/monorepo/cross-package-planner.md

@@ -1,114 +0,0 @@
-# MindForge — Cross-Package Planner
-
-## Purpose
-When a phase spans multiple packages in a monorepo, coordinate execution
-so that shared dependencies are built and tested before packages that
-depend on them.
-
-## Execution order algorithm
-
-```
-Given: a set of packages involved in the current phase
-       and their inter-package dependencies
-
-Algorithm: topological sort of package dependency graph
-
-Input: WORKSPACE-MANIFEST.json dependency_order
-Output: ordered list of packages to process
-
-Example:
-  Phase touches: @myapp/api, @myapp/shared, @myapp/web
-  Dependencies: api→shared, web→shared, web→api
-  Topological order: shared → api → web
-  
-  Execution: 
-    Wave 1: process @myapp/shared (no dependencies on other changed packages)
-    Wave 2: process @myapp/api (depends on Wave 1: shared)
-    Wave 3: process @myapp/web (depends on Wave 2: api + Wave 1: shared)
-```
-
-## Per-package PLAN file routing
-
-When PLAN files are created for a monorepo phase, each plan specifies its target package:
-
-```xml
-<task type="auto">
-  <n>Add auth middleware to API</n>
-  <package>@myapp/api</package>
-  <working-dir>apps/api</working-dir>
-  <files>
-    apps/api/src/middleware/auth.ts
-    apps/api/src/middleware/auth.test.ts
-  </files>
-  <action>...</action>
-  <verify>cd apps/api && npm test -- --testPathPattern=auth.middleware</verify>
-  <done>Auth middleware tests passing in apps/api</done>
-</task>
-```
-
-## Cross-package test execution
-
-After all packages in the phase are processed:
-```bash
-# Run tests across all affected packages
-AFFECTED_PACKAGES=$(cat .planning/WORKSPACE-MANIFEST.json | \
-  node -e "const m=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')); \
-  console.log(m.packages.map(p=>p.path).join(' '))")
-
-for PKG_PATH in ${AFFECTED_PACKAGES}; do
-  echo "Testing ${PKG_PATH}..."
-  cd "${PKG_PATH}" && npm test && cd -
-done
-
-# Run integration tests from root (if configured)
-[ -f "package.json" ] && npm run test:integration 2>/dev/null || true
-```
-
-## Affected package detection (revised)
-
-```bash
-# CORRECTED: Match against declared package paths, not assume 2-level depth
-detect_affected_packages() {
-  local MANIFEST=".planning/WORKSPACE-MANIFEST.json"
-
-  if [ ! -f "${MANIFEST}" ]; then
-    echo "Run /mindforge:workspace detect first"
-    return 1
-  fi
-
-  # Get list of changed files
-  CHANGED_FILES=$(git diff --name-only HEAD~1 2>/dev/null || git diff --cached --name-only)
-
-  # For each package in manifest, check if any changed file is within that package
-  node -e "
-    const fs = require('fs');
-    const manifest = JSON.parse(fs.readFileSync('${MANIFEST}', 'utf8'));
-    const changedFiles = \`${CHANGED_FILES}\`.split('\n').filter(Boolean);
-
-    const affected = new Set();
-    manifest.packages.forEach(pkg => {
-      // Check if any changed file is within this package's path
-      const pkgPath = pkg.path.replace(/\/$/, ''); // remove trailing slash
-      changedFiles.forEach(file => {
-        if (file.startsWith(pkgPath + '/') || file === pkgPath) {
-          affected.add(pkg.name);
-        }
-      });
-    });
-
-    // Also add packages that depend on affected packages
-    manifest.packages.forEach(pkg => {
-      if (pkg.dependencies && pkg.dependencies.some(dep => affected.has(dep))) {
-        affected.add(pkg.name);
-      }
-    });
-
-    console.log([...affected].join('\n'));
-  "
-}
-```
-
-This correctly handles:
-- Packages at any nesting depth (`libs/shared/utils/` → 3 levels deep)
-- Packages whose path is a prefix of another (avoid false matches)
-- Transitive dependencies (packages that depend on changed packages)

package/.mindforge/monorepo/dependency-graph-builder.md

@@ -1,32 +0,0 @@
-# MindForge — Dependency Graph Builder
-
-## Purpose
-Build a dependency graph of packages in a monorepo to support topological
-ordering and affected package detection.
-
-## Input
-- `.planning/WORKSPACE-MANIFEST.json`
-- Each package's `package.json` dependencies
-
-## Output
-A directed graph where nodes are packages and edges represent internal
-package dependencies.
-
-Example:
-```
-@myapp/shared → @myapp/api
-@myapp/shared → @myapp/web
-@myapp/api    → @myapp/web
-```
-
-## Steps
-
-1. Load `WORKSPACE-MANIFEST.json`.
-2. For each package, read `dependencies` and `devDependencies`.
-3. Filter dependencies to only those that match workspace package names.
-4. Build adjacency list and compute topological order.
-5. Write to `.planning/WORKSPACE-MANIFEST.json` as `dependency_order`.
-
-## Failure modes
-- Cycles detected: stop, report cycle path, require manual resolution.
-- Missing package metadata: warn and skip.