@davidorex/pi-workflows 0.5.0 → 0.9.0

package/workflows/do-gap.workflow.yaml

@@ -13,21 +13,26 @@ input:
         file: .project/gaps.json
         array: gaps
         filter: { status: open }
-        label: id
+        label: [id, description]
         value: id
 
 steps:
+  load-blocks:
+    block:
+      read: gaps
+    output:
+      format: json
+
   load:
     command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        const gapId = process.argv[1];
-        const data = JSON.parse(fs.readFileSync('.project/gaps.json', 'utf8'));
-        const gap = data.gaps.find(g => g.id === gapId);
+      node -e "
+        const gaps = JSON.parse(process.argv[1]);
+        const gapId = process.argv[2];
+        const gap = gaps.gaps.find(g => g.id === gapId);
         if (!gap) { console.error('Gap not found: ' + gapId); process.exit(1); }
-        if (gap.status === 'resolved') { console.error('Gap already resolved: ' + gapId); process.exit(1); }
+        if (gap.status === 'resolved') { console.error('Gap already resolved'); process.exit(1); }
         console.log(JSON.stringify({ gap }));
-      " '${{ input.gap_id }}'
+      " '${{ steps.load-blocks.output | json }}' '${{ input.gap_id }}'
     output:
       format: json
 
@@ -74,7 +79,7 @@ steps:
       format: json
       schema: ../schemas/execution-results.schema.json
 
-  verify:
+  run-checks:
     command: |
       node --experimental-strip-types -e "
         import fs from 'fs';
@@ -100,7 +105,9 @@ steps:
               if (stderr.includes('error')) errors.push('Lint errors in ' + f);
             }
           }
-        } catch {}
+        } catch (e) {
+          errors.push('Could not determine changed files: ' + (e.message || 'unknown'));
+        }
 
         // Validate blocks (JSON parsability)
         try {
@@ -115,7 +122,9 @@ steps:
               }
             }
           }
-        } catch {}
+        } catch (e) {
+          errors.push('Block validation error: ' + (e.message || 'unknown'));
+        }
 
         const passed = errors.length === 0;
         console.log(JSON.stringify({ status: passed ? 'passed' : 'failed', errors, passed }));
@@ -123,33 +132,44 @@ steps:
     output:
       format: json
 
+  assess-resolution:
+    when: "${{ steps.run-checks.output.passed }}"
+    agent: gap-resolution-assessor
+    input:
+      gap: "${{ steps.load.output.gap }}"
+      investigation: "${{ steps.investigate.output }}"
+      implementation_results: "${{ steps.implement.output }}"
+      check_results: "${{ steps.run-checks.output }}"
+    context: [implement]
+    output:
+      format: json
+      schema: ../schemas/resolution-assessment.schema.json
+
   route:
-    when: "${{ steps.verify.output.passed }}"
-    command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        const gapId = process.argv[1];
-        const gapsPath = '.project/gaps.json';
-        const data = JSON.parse(fs.readFileSync(gapsPath, 'utf8'));
-        const gap = data.gaps.find(g => g.id === gapId);
-        if (!gap) { console.error('Gap not found: ' + gapId); process.exit(1); }
-        Object.assign(gap, { status: 'resolved', resolved_by: 'do-gap-workflow' });
-        fs.writeFileSync(gapsPath, JSON.stringify(data, null, 2) + '\n');
-        console.log(JSON.stringify({ routed: true, gap_id: gapId, status: 'resolved' }));
-      " '${{ input.gap_id }}'
+    when: "${{ steps.assess-resolution.output.resolved }}"
+    block:
+      update:
+        name: gaps
+        key: gaps
+        match:
+          id: "${{ input.gap_id }}"
+        set:
+          status: resolved
+          resolved_by: "${{ steps.assess-resolution.output.resolution_summary }}"
     output:
       format: json
 
   check:
-    when: "${{ steps.route.output.routed }}"
+    when: "${{ steps.route.output.updated }}"
     gate:
-      check: "test '${{ steps.verify.output.status }}' = 'passed'"
+      check: "test '${{ steps.assess-resolution.output.resolved }}' = 'true'"
       onFail: fail
 
 completion:
   message: |
-    Gap ${{ input.gap_id }} — ${{ steps.verify.output.status }}
+    Gap ${{ input.gap_id }} — ${{ steps.assess-resolution.output.verdict }}
     Investigation complexity: ${{ steps.investigate.output.complexity }}
     Specs implemented: ${{ steps.decompose.output.specs | length }}
+    Resolution: ${{ steps.assess-resolution.output.resolution_summary }}
   include:
-    - steps.verify.output
+    - steps.assess-resolution.output

package/workflows/fix-audit.workflow.yaml

@@ -3,41 +3,35 @@ description: Fix audit findings grouped by related clusters
 version: "1"
 
 steps:
-  load:
-    command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        const auditsDir = '.project/audits';
-        const files = fs.readdirSync(auditsDir).filter(f => f.endsWith('.json')).sort();
-        const latestFile = files[files.length - 1];
-        const auditPath = auditsDir + '/' + latestFile;
-        const audit = JSON.parse(fs.readFileSync(auditPath, 'utf8'));
-        let conformance_reference = null;
-        try { conformance_reference = JSON.parse(fs.readFileSync('.project/conformance-reference.json', 'utf8')); } catch {}
-        console.log(JSON.stringify({ audit, conformance_reference, audit_path: auditPath }));
-      "
+  load-audits:
+    block:
+      readDir: audits
+    output:
+      format: json
+
+  load-conformance:
+    block:
+      read: conformance-reference
+      optional: [conformance-reference]
     output:
       format: json
 
+  select-audit:
+    transform:
+      mapping:
+        audit: "${{ steps.load-audits.output | last }}"
+        conformance_reference: "${{ steps.load-conformance.output }}"
+
   cluster:
     command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        import { execSync } from 'child_process';
-        const audit = JSON.parse(fs.readFileSync('.project/audits/' + fs.readdirSync('.project/audits').filter(f => f.endsWith('.json')).sort().pop(), 'utf8'));
+      node -e "
+        const audit = JSON.parse(process.argv[1]);
 
-        // Filter to findings that still need fixing (code is source of truth)
+        // Filter to findings that have fixes and are not already resolved
         const findings = audit.findings.filter(f => {
           if (!f.fix) return false;
-          if (f.fix.verify_method === 'grep' && f.fix.verify_pattern) {
-            try {
-              execSync('grep -rn ' + JSON.stringify(f.fix.verify_pattern) + ' ' + f.locations.map(l => l.file).join(' '), { stdio: 'pipe' });
-              return true;  // pattern still matches — needs fixing
-            } catch { return false; }  // pattern gone — already fixed
-          }
-          // inspect findings: check resolution field, skip if already resolved
           if (f.resolution && f.resolution.status === 'passed') return false;
-          return true;  // no automated check — include it
+          return true;
         });
 
         if (findings.length === 0) {
@@ -67,14 +61,11 @@ steps:
             principle: cluster[0].principle,
             category: cluster[0].category,
             severity: cluster.some(c => c.severity === 'error') ? 'error' : cluster[0].severity,
-            acceptance_criteria: cluster.map(c => {
-              if (c.fix && c.fix.verify_method === 'grep' && c.fix.verify_pattern) return 'grep pattern should not match: ' + c.fix.verify_pattern + ' in ' + c.locations.map(l=>l.file).join(', ');
-              return 'Fix: ' + (c.fix?.suggestion || c.description);
-            })
+            acceptance_criteria: cluster.map(c => 'Fix: ' + (c.fix?.suggestion || c.description))
           });
         }
         console.log(JSON.stringify({ tasks }));
-      "
+      " '${{ steps.select-audit.output.audit | json }}'
     output:
       format: json
 
@@ -84,121 +75,92 @@ steps:
     agent: audit-fixer
     input:
       task: "${{ task }}"
-      conformance_reference: "${{ steps.load.output.conformance_reference }}"
+      conformance_reference: "${{ steps.select-audit.output.conformance_reference }}"
     output:
       format: json
       schema: ../schemas/execution-results.schema.json
       path: .project/fix-audit-results.json
 
-  route-results:
-    command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        const raw = JSON.parse(fs.readFileSync('.project/fix-audit-results.json', 'utf8'));
-        const items = Array.isArray(raw) ? raw : [raw];
-
-        const decisionsPath = '.project/decisions.json';
-        if (fs.existsSync(decisionsPath)) {
-          const d = JSON.parse(fs.readFileSync(decisionsPath, 'utf8'));
-          const existingIds = new Set(d.decisions.map(x => x.id));
-          for (const r of items) {
-            for (const dec of r.decisions || []) {
-              if (!existingIds.has(dec.id)) { d.decisions.push(dec); existingIds.add(dec.id); }
-            }
-          }
-          fs.writeFileSync(decisionsPath, JSON.stringify(d, null, 2) + '\n');
-        }
-
-        const gapsPath = '.project/gaps.json';
-        if (fs.existsSync(gapsPath)) {
-          const g = JSON.parse(fs.readFileSync(gapsPath, 'utf8'));
-          const existingIds = new Set(g.gaps.map(x => x.id));
-          for (const r of items) {
-            for (const issue of r.issues || []) {
-              const id = 'issue-' + issue.description.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50);
-              if (!existingIds.has(id)) {
-                g.gaps.push({ id, description: issue.description, status: 'open', category: 'issue', priority: issue.severity === 'critical' ? 'high' : issue.severity === 'error' ? 'medium' : 'low', source: 'agent' });
-                existingIds.add(id);
-              }
-            }
-          }
-          fs.writeFileSync(gapsPath, JSON.stringify(g, null, 2) + '\n');
-        }
-
-        const invPath = '.project/inventory.json';
-        if (fs.existsSync(invPath)) {
-          const inv = JSON.parse(fs.readFileSync(invPath, 'utf8'));
-          let maxTests = inv.test_count || 0;
-          for (const r of items) { if (r.test_count && r.test_count > maxTests) maxTests = r.test_count; }
-          if (maxTests > inv.test_count) { inv.test_count = maxTests; fs.writeFileSync(invPath, JSON.stringify(inv, null, 2) + '\n'); }
-        }
-
-        const statePath = '.project/state.json';
-        if (fs.existsSync(statePath)) {
-          const s = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-          const lastCommit = items.filter(r => r.commit_hash).pop()?.commit_hash;
-          if (lastCommit) s.last_commit = lastCommit;
-          const maxTests = Math.max(...items.map(r => r.test_count || 0));
-          if (maxTests > 0) s.test_count = maxTests;
-          s.session.last_action = 'fix-audit workflow: ' + items.length + ' tasks completed';
-          fs.writeFileSync(statePath, JSON.stringify(s, null, 2) + '\n');
-        }
+  verify-findings:
+    agent: audit-finding-verifier
+    input:
+      audit: "${{ steps.select-audit.output.audit }}"
+      implementation_results: "${{ steps.implement.output }}"
+      conformance_reference: "${{ steps.select-audit.output.conformance_reference }}"
+    context: [implement]
+    output:
+      format: json
+      schema: ../schemas/finding-verification.schema.json
+      path: .project/fix-audit-verify.json
 
-        console.log(JSON.stringify({ routed: items.length, decisions_added: items.reduce((s,r) => s + (r.decisions?.length || 0), 0), issues_added: items.reduce((s,r) => s + (r.issues?.length || 0), 0) }));
-      "
+  prepare-routing:
+    agent: audit-results-router
+    input:
+      implementation_results: "${{ steps.implement.output }}"
+      verification: "${{ steps.verify-findings.output }}"
+    context: [implement, verify-findings]
+    output:
+      format: json
+      schema: ../schemas/audit-routing-manifest.schema.json
+
+  route-decisions:
+    when: "${{ steps.prepare-routing.output.decisions | length }}"
+    forEach: "${{ steps.prepare-routing.output.decisions }}"
+    as: decision
+    block:
+      append:
+        name: decisions
+        key: decisions
+        item: "${{ decision }}"
     output:
       format: json
 
-  verify:
-    command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        import { execSync } from 'child_process';
-        const auditPath = '.project/audits/' + fs.readdirSync('.project/audits').filter(f => f.endsWith('.json')).sort().pop();
-        const audit = JSON.parse(fs.readFileSync(auditPath, 'utf8'));
-        const results = [];
-        for (const finding of audit.findings) {
-          const fix = finding.fix;
-          if (!fix) { results.push({ id: finding.id, status: 'skipped', reason: 'no fix defined' }); continue; }
-          if (fix.verify_method === 'grep' && fix.verify_pattern) {
-            try {
-              execSync('grep -rn ' + JSON.stringify(fix.verify_pattern) + ' ' + finding.locations.map(l => l.file).join(' '), { encoding: 'utf8' });
-              results.push({ id: finding.id, status: 'failed', reason: 'pattern still matches' });
-            } catch { results.push({ id: finding.id, status: 'passed' }); }
-          } else {
-            results.push({ id: finding.id, status: 'needs_inspect', reason: fix.verify_method });
-          }
-        }
-        const passed = results.filter(r => r.status === 'passed').length;
-        const failed = results.filter(r => r.status === 'failed').length;
-        const inspect = results.filter(r => r.status === 'needs_inspect').length;
-        const total = results.length;
-        const status = failed === 0 ? (inspect > 0 ? 'passed_with_inspect' : 'passed') : 'gaps_found';
-        console.log(JSON.stringify({ status, score: passed + '/' + total, passed, failed, needs_inspect: inspect, results }));
-      "
+  route-issues:
+    when: "${{ steps.prepare-routing.output.new_gaps | length }}"
+    forEach: "${{ steps.prepare-routing.output.new_gaps }}"
+    as: gap_item
+    block:
+      append:
+        name: gaps
+        key: gaps
+        item: "${{ gap_item }}"
     output:
       format: json
-      path: .project/fix-audit-verify.json
 
   update-audit:
     command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        const auditPath = '.project/audits/' + fs.readdirSync('.project/audits').filter(f => f.endsWith('.json')).sort().pop();
+      node -e "
+        const fs = require('fs');
+        const auditsDir = '.project/audits';
+        const auditFile = fs.readdirSync(auditsDir).filter(f => f.endsWith('.json')).sort().pop();
+        if (!auditFile) { console.error('No audit files found'); process.exit(1); }
+        const auditPath = auditsDir + '/' + auditFile;
         const verifyPath = '.project/fix-audit-verify.json';
         let verifyResults;
-        try { verifyResults = JSON.parse(fs.readFileSync(verifyPath, 'utf8')); } catch { console.log(JSON.stringify({ updated: null, reason: 'cannot read verify output' })); process.exit(0); }
+        try {
+          verifyResults = JSON.parse(fs.readFileSync(verifyPath, 'utf8'));
+        } catch (e) {
+          console.error('Cannot read verification output: ' + e.message);
+          process.exit(1);
+        }
+
         const audit = JSON.parse(fs.readFileSync(auditPath, 'utf8'));
-        for (const vr of verifyResults.results || []) {
+        let resolved = 0;
+        for (const vr of verifyResults.findings || []) {
           const finding = audit.findings.find(f => f.id === vr.id);
           if (finding) {
-            finding.resolution = { status: vr.status, verified_at: new Date().toISOString() };
+            finding.resolution = {
+              status: vr.status,
+              verified_at: new Date().toISOString(),
+              verified_by: 'agent',
+              evidence: vr.evidence || null
+            };
+            if (vr.status === 'passed') resolved++;
           }
         }
-        const passed = (verifyResults.results || []).filter(r => r.status === 'passed').length;
-        audit.summary.resolved = passed;
+        audit.summary.resolved = resolved;
         fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2) + '\n');
-        console.log(JSON.stringify({ updated: auditPath, resolved: passed, total: audit.findings.length }));
+        console.log(JSON.stringify({ updated: auditPath, resolved, total: audit.findings.length }));
       "
     output:
       format: json
@@ -206,12 +168,12 @@ steps:
   check:
     when: "${{ steps.update-audit.output.updated }}"
     gate:
-      check: "test '${{ steps.verify.output.failed }}' = '0'"
+      check: "test '${{ steps.verify-findings.output.status }}' != 'gaps_found'"
       onFail: fail
 
 completion:
   message: |
     Audit fix workflow completed.
-    Verification: ${{ steps.verify.output.status }} (${{ steps.verify.output.score }})
+    Verification: ${{ steps.verify-findings.output.status }} (${{ steps.verify-findings.output.score }})
   include:
-    - steps.verify.output.results
+    - steps.verify-findings.output.findings

package/workflows/gap-to-phase.workflow.yaml

@@ -17,45 +17,45 @@ input:
         value: id
 
 steps:
+  load-gap-blocks:
+    block:
+      read: gaps
+    output:
+      format: json
+
   load-gap:
     command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        const gapId = process.argv[1];
-        const data = JSON.parse(fs.readFileSync('.project/gaps.json', 'utf8'));
-        const gap = data.gaps.find(g => g.id === gapId);
+      node -e "
+        const gaps = JSON.parse(process.argv[1]);
+        const gapId = process.argv[2];
+        const gap = gaps.gaps.find(g => g.id === gapId);
         if (!gap) { console.error('Gap not found: ' + gapId); process.exit(1); }
-        if (gap.status === 'resolved') { console.error('Gap already resolved: ' + gapId); process.exit(1); }
+        if (gap.status === 'resolved') { console.error('Gap already resolved'); process.exit(1); }
         console.log(JSON.stringify({ gap }));
-      " '${{ input.gap_id }}'
+      " '${{ steps.load-gap-blocks.output | json }}' '${{ input.gap_id }}'
     output:
       format: json
 
-  load-context:
-    command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        import path from 'path';
-
-        const phases = [];
-        const phasesDir = '.project/phases';
-        if (fs.existsSync(phasesDir)) {
-          for (const f of fs.readdirSync(phasesDir).filter(f => f.endsWith('.json')).sort()) {
-            phases.push(JSON.parse(fs.readFileSync(path.join(phasesDir, f), 'utf8')));
-          }
-        }
+  load-phases:
+    block:
+      readDir: phases
+    output:
+      format: json
 
-        let architecture = {};
-        try { architecture = JSON.parse(fs.readFileSync('.project/architecture.json', 'utf8')); } catch {}
-        let conventions = {};
-        try { conventions = JSON.parse(fs.readFileSync('.project/conventions.json', 'utf8')); } catch {}
-        let gaps = { gaps: [] };
-        try { gaps = JSON.parse(fs.readFileSync('.project/gaps.json', 'utf8')); } catch {}
-        let inventory = {};
-        try { inventory = JSON.parse(fs.readFileSync('.project/inventory.json', 'utf8')); } catch {}
+  load-context:
+    block:
+      read: [architecture, conventions, gaps, inventory]
+      optional: [architecture, conventions, inventory]
+    output:
+      format: json
 
-        console.log(JSON.stringify({ phases, architecture, conventions, gaps: gaps.gaps.filter(g => g.status === 'open'), inventory }));
-      "
+  filter-gaps:
+    command: |
+      node -e "
+        const data = JSON.parse(process.argv[1]);
+        const open = (data.gaps || []).filter(g => g.status === 'open');
+        console.log(JSON.stringify(open));
+      " '${{ steps.load-context.output.gaps | json }}'
     output:
       format: json
 
@@ -64,34 +64,39 @@ steps:
     input:
       intent: "Implement gap ${{ steps.load-gap.output.gap.id }}: ${{ steps.load-gap.output.gap.description }}"
       gap: "${{ steps.load-gap.output.gap }}"
-      phases: "${{ steps.load-context.output.phases }}"
+      phases: "${{ steps.load-phases.output }}"
       architecture: "${{ steps.load-context.output.architecture }}"
       conventions: "${{ steps.load-context.output.conventions }}"
-      gaps: "${{ steps.load-context.output.gaps }}"
+      gaps: "${{ steps.filter-gaps.output }}"
       inventory: "${{ steps.load-context.output.inventory }}"
     output:
       format: json
       schema: block:phase
 
-  write-phase:
+  compute-phase-path:
     command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
+      node -e "
         const phase = JSON.parse(process.argv[1]);
         const num = String(phase.number).padStart(2, '0');
-        const name = phase.name.toLowerCase().replace(/\s+/g, '-');
-        const filename = '.project/phases/' + num + '-' + name + '.json';
-        fs.mkdirSync('.project/phases', { recursive: true });
-        fs.writeFileSync(filename, JSON.stringify(phase, null, 2));
-        console.log(JSON.stringify({ path: filename, phase_number: phase.number, spec_count: (phase.specs || []).length }));
+        const name = phase.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+$/g, '');
+        console.log(JSON.stringify({ path: 'phases/' + num + '-' + name }));
       " '${{ steps.author.output | json }}'
     output:
       format: json
 
+  write-phase:
+    block:
+      write:
+        name: phase
+        data: "${{ steps.author.output }}"
+        path: "${{ steps.compute-phase-path.output.path }}"
+    output:
+      format: json
+
 completion:
   message: |
-    Phase ${{ steps.write-phase.output.phase_number }} created: ${{ steps.write-phase.output.path }}
-    Specs: ${{ steps.write-phase.output.spec_count }}
+    Phase ${{ steps.author.output.number }} created: ${{ steps.write-phase.output.path }}
+    Specs: ${{ steps.author.output.specs | length }}
     From gap: ${{ input.gap_id }}
   include:
     - steps.author.output

package/workflows/parallel-analysis.workflow.yaml

@@ -25,38 +25,50 @@ steps:
   analyze-structure:
     agent: structure-analyzer
     input:
-      exploration: ${{ steps.explore.textOutput }}
+      exploration: ${{ steps.explore.output }}
       path: ${{ input.path }}
+    output:
+      format: json
+      schema: ../schemas/structure-analysis.schema.json
 
   analyze-quality:
     agent: quality-analyzer
     input:
-      exploration: ${{ steps.explore.textOutput }}
+      exploration: ${{ steps.explore.output }}
       path: ${{ input.path }}
+    output:
+      format: json
+      schema: ../schemas/quality-analysis.schema.json
 
   analyze-patterns:
     agent: pattern-analyzer
     input:
-      exploration: ${{ steps.explore.textOutput }}
+      exploration: ${{ steps.explore.output }}
       path: ${{ input.path }}
+    output:
+      format: json
+      schema: ../schemas/pattern-analysis.schema.json
 
   # This step depends on all three analyzers — it must wait for all to complete
   synthesize:
     agent: synthesizer
     input:
-      structure: ${{ steps.analyze-structure.textOutput }}
-      quality: ${{ steps.analyze-quality.textOutput }}
-      patterns: ${{ steps.analyze-patterns.textOutput }}
+      structure: ${{ steps.analyze-structure.output }}
+      quality: ${{ steps.analyze-quality.output }}
+      patterns: ${{ steps.analyze-patterns.output }}
       focus: ${{ input.focus }}
+    output:
+      format: json
+      schema: ../schemas/synthesis.schema.json
 
 artifacts:
   report:
     path: latest-analysis.md
-    from: steps.synthesize.textOutput
+    from: steps.synthesize.output
 
 completion:
   message: |
     Present this code analysis report to the user. Highlight the most important
     findings and any areas that need immediate attention.
   include:
-    - steps.synthesize.textOutput
+    - steps.synthesize.output

package/workflows/plan-from-requirements.workflow.yaml

@@ -3,33 +3,22 @@ description: Decompose accepted requirements into phases and tasks
 version: "1"
 
 steps:
-  load-context:
-    command: |
-      node -e "
-        const fs = require('fs');
-        const path = require('path');
-        const projectDir = '.project';
-        const context = {};
-
-        // Read requirements
-        try { context.requirements = JSON.parse(fs.readFileSync(path.join(projectDir, 'requirements.json'), 'utf-8')); } catch { context.requirements = { requirements: [] }; }
-
-        // Read architecture
-        try { context.architecture = JSON.parse(fs.readFileSync(path.join(projectDir, 'architecture.json'), 'utf-8')); } catch { context.architecture = null; }
-
-        // Read project identity
-        try { context.project = JSON.parse(fs.readFileSync(path.join(projectDir, 'project.json'), 'utf-8')); } catch { context.project = null; }
+  load-requirements:
+    block:
+      read: requirements
+    output:
+      format: json
 
-        // Read existing phases
-        try {
-          const phasesDir = path.join(projectDir, 'phases');
-          context.existing_phases = fs.readdirSync(phasesDir).filter(f => f.endsWith('.json')).map(f => {
-            try { return JSON.parse(fs.readFileSync(path.join(phasesDir, f), 'utf-8')); } catch { return null; }
-          }).filter(Boolean);
-        } catch { context.existing_phases = []; }
+  load-context:
+    block:
+      read: [architecture, project]
+      optional: [architecture, project]
+    output:
+      format: json
 
-        console.log(JSON.stringify(context));
-      "
+  load-phases:
+    block:
+      readDir: phases
     output:
       format: json
 
@@ -37,9 +26,9 @@ steps:
     agent: plan-creator
     input:
       project: ${{ steps.load-context.output.project }}
-      requirements: ${{ steps.load-context.output.requirements }}
+      requirements: ${{ steps.load-requirements.output }}
       architecture: ${{ steps.load-context.output.architecture }}
-      existing_phases: ${{ steps.load-context.output.existing_phases }}
+      existing_phases: ${{ steps.load-phases.output }}
     output:
       format: json
       schema: block:tasks