@davidorex/pi-workflows 0.6.1 → 0.9.1

package/workflows/create-handoff.workflow.yaml

@@ -3,52 +3,73 @@ description: Capture current work context for session resume
 version: "1"
 
 steps:
-  load-state:
-    command: |
-      node -e "
-        const fs = require('fs');
-        const path = require('path');
-        const projectDir = '.project';
-        const state = {};
-
-        // Read project identity
-        try { state.project = JSON.parse(fs.readFileSync(path.join(projectDir, 'project.json'), 'utf-8')); } catch {}
+  load-blocks:
+    block:
+      read: [project, gaps, decisions, tasks]
+      optional: [project, gaps, decisions, tasks]
+    output:
+      format: json
 
-        // Read phase files
-        try {
-          const phasesDir = path.join(projectDir, 'phases');
-          state.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 { state.phases = []; }
+  load-phases:
+    block:
+      readDir: phases
+    output:
+      format: json
 
-        // Read block summaries
-        try {
-          state.gaps = JSON.parse(fs.readFileSync(path.join(projectDir, 'gaps.json'), 'utf-8'));
-        } catch {}
-        try {
-          state.decisions = JSON.parse(fs.readFileSync(path.join(projectDir, 'decisions.json'), 'utf-8'));
-        } catch {}
+  load-git:
+    command: |
+      node -e "
+        const { execSync } = require('child_process');
+        const git = {};
         try {
-          state.tasks = JSON.parse(fs.readFileSync(path.join(projectDir, 'tasks.json'), 'utf-8'));
-        } catch {}
-
-        // Recent git activity
+          git.recent_commits = execSync('git log --oneline -10', { encoding: 'utf-8' }).trim().split('\n');
+        } catch (e) {
+          git.recent_commits = [];
+          git.commits_error = e.message || 'git log failed';
+        }
         try {
-          const { execSync } = require('child_process');
-          state.recent_commits = execSync('git log --oneline -10', { encoding: 'utf-8' }).trim().split('\n');
-          state.changed_files = execSync('git diff --name-only HEAD~3 2>/dev/null || echo \"\"', { encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
-        } catch { state.recent_commits = []; state.changed_files = []; }
-
-        console.log(JSON.stringify(state));
+          git.changed_files = execSync('git diff --name-only HEAD~3 2>/dev/null || echo \"\"', { encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
+        } catch (e) {
+          git.changed_files = [];
+          git.files_error = e.message || 'git diff failed';
+        }
+        console.log(JSON.stringify(git));
       "
     output:
       format: json
 
+  assemble-state:
+    command: |
+      node -e "
+        const blocks = JSON.parse(process.argv[1]);
+        const phases = JSON.parse(process.argv[2]);
+        const git = JSON.parse(process.argv[3]);
+        console.log(JSON.stringify({
+          project: blocks.project,
+          phases: phases,
+          gaps: blocks.gaps,
+          decisions: blocks.decisions,
+          tasks: blocks.tasks,
+          recentCommits: git.recent_commits || [],
+          changedFiles: git.changed_files || [],
+          blocks_status: {
+            project: blocks.project != null,
+            gaps: blocks.gaps != null,
+            decisions: blocks.decisions != null,
+            tasks: blocks.tasks != null,
+            phases: phases.length > 0,
+            git_commits: !git.commits_error,
+            git_files: !git.files_error
+          }
+        }));
+      " '${{ steps.load-blocks.output | json }}' '${{ steps.load-phases.output | json }}' '${{ steps.load-git.output | json }}'
+    output:
+      format: json
+
   capture:
     agent: handoff-writer
     input:
-      project_state: ${{ steps.load-state.output }}
+      project_state: ${{ steps.assemble-state.output }}
       path: "."
     output:
       format: json

package/workflows/create-phase.workflow.yaml

@@ -11,28 +11,16 @@ input:
       description: Unstructured intent from conversation — what needs to be built and why
 
 steps:
+  load-phases:
+    block:
+      readDir: phases
+    output:
+      format: json
+
   load-context:
-    command: |
-      node --experimental-strip-types -e "
-        import fs from 'fs';
-        import path from 'path';
-        const phasesDir = '.project/phases';
-        let phases = [];
-        try {
-          phases = fs.readdirSync(phasesDir)
-            .filter(f => f.endsWith('.json'))
-            .map(f => JSON.parse(fs.readFileSync(path.join(phasesDir, f), 'utf8')));
-        } catch {}
-        let arch = {};
-        try { arch = JSON.parse(fs.readFileSync('.project/architecture.json', 'utf8')); } catch {}
-        let conv = {};
-        try { conv = JSON.parse(fs.readFileSync('.project/conventions.json', 'utf8')); } catch {}
-        let gapsData = { gaps: [] };
-        try { gapsData = JSON.parse(fs.readFileSync('.project/gaps.json', 'utf8')); } catch {}
-        let inv = {};
-        try { inv = JSON.parse(fs.readFileSync('.project/inventory.json', 'utf8')); } catch {}
-        console.log(JSON.stringify({ phases, architecture: arch, conventions: conv, gaps: gapsData.gaps, inventory: inv }));
-      "
+    block:
+      read: [architecture, conventions, gaps, inventory]
+      optional: [architecture, conventions, gaps, inventory]
     output:
       format: json
 
@@ -40,32 +28,39 @@ steps:
     agent: phase-author
     input:
       intent: "${{ input.intent }}"
-      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.load-context.output.gaps.gaps }}"
       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 filename = '.project/phases/' + String(phase.number).padStart(2, '0') + '-' + phase.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+$/, '') + '.json';
-        fs.mkdirSync('.project/phases', { recursive: true });
-        fs.writeFileSync(filename, JSON.stringify(phase, null, 2) + '\n');
-        console.log(JSON.stringify({ path: filename, phase_number: phase.number, spec_count: phase.specs.length }));
+        const num = String(phase.number).padStart(2, '0');
+        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 at ${{ steps.write-phase.output.path }}
-    Contains ${{ steps.write-phase.output.spec_count }} specs.
+    Phase ${{ steps.author.output.number }} created at ${{ steps.write-phase.output.path }}
+    Contains ${{ steps.author.output.specs | length }} specs.
   include:
     - steps.author.output.success_criteria
     - steps.author.output.specs

package/workflows/do-gap.workflow.yaml

@@ -17,17 +17,22 @@ input:
         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