@ktpartners/dgs-platform 2.8.0 → 3.0.4

package/deliver-great-systems/bin/lib/jobs.test.cjs

@@ -663,85 +663,94 @@ describe('jobs', () => {
 
   describe('generateMilestoneSteps', () => {
 
-    it('produces 4 steps for unplanned phase (no_directory)', () => {
+    it('produces 5 steps for unplanned phase (no_directory)', () => {
       const phases = [
         { number: '50', name: 'Job Creation', disk_status: 'no_directory', roadmap_complete: false },
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      assert.equal(steps.length, 4);
+      assert.equal(steps.length, 5);
       assert.equal(steps[0].command, 'map-codebase');
       assert.equal(steps[0].args, '50 --auto');
       assert.equal(steps[1].command, 'plan-phase');
       assert.equal(steps[1].args, '50 --non-interactive');
       assert.equal(steps[2].command, 'execute-phase');
       assert.equal(steps[2].args, '50 --non-interactive');
-      assert.equal(steps[3].command, 'audit-phase');
-      assert.equal(steps[3].args, '50');
+      assert.equal(steps[3].command, 'validate-phase');
+      assert.equal(steps[3].args, '50 --scaffold');
+      assert.equal(steps[4].command, 'audit-phase');
+      assert.equal(steps[4].args, '50');
     });
 
-    it('produces 4 steps for unplanned phase (empty)', () => {
+    it('produces 5 steps for unplanned phase (empty)', () => {
       const phases = [
         { number: '51', name: 'Job Execution', disk_status: 'empty', roadmap_complete: false },
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      assert.equal(steps.length, 4);
+      assert.equal(steps.length, 5);
       assert.equal(steps[0].command, 'map-codebase');
       assert.equal(steps[1].command, 'plan-phase');
       assert.equal(steps[2].command, 'execute-phase');
-      assert.equal(steps[3].command, 'audit-phase');
+      assert.equal(steps[3].command, 'validate-phase');
+      assert.equal(steps[4].command, 'audit-phase');
     });
 
-    it('produces 4 steps for discussed phase (context but no plan)', () => {
+    it('produces 5 steps for discussed phase (context but no plan)', () => {
       const phases = [
         { number: '52', name: 'Silent Mode', disk_status: 'discussed', roadmap_complete: false },
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      assert.equal(steps.length, 4);
+      assert.equal(steps.length, 5);
       assert.equal(steps[0].command, 'map-codebase');
       assert.equal(steps[1].command, 'plan-phase');
       assert.equal(steps[2].command, 'execute-phase');
-      assert.equal(steps[3].command, 'audit-phase');
+      assert.equal(steps[3].command, 'validate-phase');
+      assert.equal(steps[4].command, 'audit-phase');
     });
 
-    it('produces 4 steps for researched phase', () => {
+    it('produces 5 steps for researched phase', () => {
       const phases = [
         { number: '53', name: 'Audit Integration', disk_status: 'researched', roadmap_complete: false },
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      assert.equal(steps.length, 4);
+      assert.equal(steps.length, 5);
       assert.equal(steps[0].command, 'map-codebase');
       assert.equal(steps[1].command, 'plan-phase');
       assert.equal(steps[2].command, 'execute-phase');
-      assert.equal(steps[3].command, 'audit-phase');
+      assert.equal(steps[3].command, 'validate-phase');
+      assert.equal(steps[4].command, 'audit-phase');
     });
 
-    it('produces 2 steps for planned phase', () => {
+    it('produces 3 steps for planned phase', () => {
       const phases = [
         { number: '50', name: 'Job Creation', disk_status: 'planned', roadmap_complete: false },
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      assert.equal(steps.length, 2);
+      assert.equal(steps.length, 3);
       assert.equal(steps[0].command, 'execute-phase');
       assert.equal(steps[0].args, '50 --non-interactive');
-      assert.equal(steps[1].command, 'audit-phase');
-      assert.equal(steps[1].args, '50');
+      assert.equal(steps[1].command, 'validate-phase');
+      assert.equal(steps[1].args, '50 --scaffold');
+      assert.equal(steps[2].command, 'audit-phase');
+      assert.equal(steps[2].args, '50');
     });
 
-    it('produces 2 steps for partially executed phase', () => {
+    it('produces 3 steps for partially executed phase', () => {
       const phases = [
         { number: '50', name: 'Job Creation', disk_status: 'partial', roadmap_complete: false },
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      assert.equal(steps.length, 2);
+      assert.equal(steps.length, 3);
       assert.equal(steps[0].command, 'execute-phase');
-      assert.equal(steps[1].command, 'audit-phase');
-      assert.equal(steps[1].args, '50');
+      assert.equal(steps[1].command, 'validate-phase');
+      assert.equal(steps[1].args, '50 --scaffold');
+      assert.equal(steps[2].command, 'audit-phase');
+      assert.equal(steps[2].args, '50');
     });
 
     it('produces 0 steps for completed phase (disk_status complete)', () => {
@@ -771,34 +780,38 @@ describe('jobs', () => {
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
       // Phase 49: 0 steps (complete)
-      // Phase 50: 2 steps (planned -> execute + verify)
-      // Phase 51: 4 steps (unplanned -> map + plan + execute + verify)
-      assert.equal(steps.length, 6);
+      // Phase 50: 3 steps (planned -> execute + validate + audit)
+      // Phase 51: 5 steps (unplanned -> map + plan + execute + validate + audit)
+      assert.equal(steps.length, 8);
       assert.equal(steps[0].command, 'execute-phase');
       assert.equal(steps[0].args, '50 --non-interactive');
-      assert.equal(steps[1].command, 'audit-phase');
-      assert.equal(steps[1].args, '50');
-      assert.equal(steps[2].command, 'map-codebase');
-      assert.equal(steps[2].args, '51 --auto');
-      assert.equal(steps[3].command, 'plan-phase');
-      assert.equal(steps[3].args, '51 --non-interactive');
-      assert.equal(steps[4].command, 'execute-phase');
+      assert.equal(steps[1].command, 'validate-phase');
+      assert.equal(steps[1].args, '50 --scaffold');
+      assert.equal(steps[2].command, 'audit-phase');
+      assert.equal(steps[2].args, '50');
+      assert.equal(steps[3].command, 'map-codebase');
+      assert.equal(steps[3].args, '51 --auto');
+      assert.equal(steps[4].command, 'plan-phase');
       assert.equal(steps[4].args, '51 --non-interactive');
-      assert.equal(steps[5].command, 'audit-phase');
-      assert.equal(steps[5].args, '51');
+      assert.equal(steps[5].command, 'execute-phase');
+      assert.equal(steps[5].args, '51 --non-interactive');
+      assert.equal(steps[6].command, 'validate-phase');
+      assert.equal(steps[6].args, '51 --scaffold');
+      assert.equal(steps[7].command, 'audit-phase');
+      assert.equal(steps[7].args, '51');
     });
 
-    it('appends audit and complete steps when check=true', () => {
+    it('appends audit step when check=true', () => {
       const phases = [
         { number: '50', name: 'Job Creation', disk_status: 'planned', roadmap_complete: false },
       ];
       const steps = generateMilestoneSteps(phases, { check: true, version: 'v6.0' });
 
-      // 2 phase steps + 2 check steps = 4
+      // 3 phase steps + 1 audit step = 4
       assert.equal(steps.length, 4);
-      assert.equal(steps[2].command, 'audit-milestone');
-      assert.equal(steps[2].args, 'v6.0');
-      assert.equal(steps[3].command, 'complete-milestone');
+      assert.equal(steps[1].command, 'validate-phase');
+      assert.equal(steps[2].command, 'audit-phase');
+      assert.equal(steps[3].command, 'audit-milestone');
       assert.equal(steps[3].args, 'v6.0');
     });
 
@@ -808,22 +821,21 @@ describe('jobs', () => {
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      assert.equal(steps.length, 2);
-      // No audit/complete steps
+      assert.equal(steps.length, 3);
+      // No audit-milestone/complete-milestone steps
       assert.ok(!steps.some(s => s.command === 'audit-milestone'));
       assert.ok(!steps.some(s => s.command === 'complete-milestone'));
     });
 
-    it('returns only audit+complete when all phases complete and check=true', () => {
+    it('returns only audit when all phases complete and check=true', () => {
       const phases = [
         { number: '49', name: 'Job File Format', disk_status: 'complete', roadmap_complete: true },
         { number: '50', name: 'Job Creation', disk_status: 'complete', roadmap_complete: true },
       ];
       const steps = generateMilestoneSteps(phases, { check: true, version: 'v6.0' });
 
-      assert.equal(steps.length, 2);
+      assert.equal(steps.length, 1);
       assert.equal(steps[0].command, 'audit-milestone');
-      assert.equal(steps[1].command, 'complete-milestone');
     });
 
     it('returns empty array when all phases complete and check=false', () => {
@@ -844,15 +856,15 @@ describe('jobs', () => {
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      // Phase 50: 2 steps (execute + verify), Phase 50.1: 4 steps (map + plan + execute + verify), Phase 51: 2 steps (execute + verify) = 8 total
-      assert.equal(steps.length, 8);
+      // Phase 50: 3 steps (execute + validate + audit), Phase 50.1: 5 steps (map + plan + execute + validate + audit), Phase 51: 3 steps (execute + validate + audit) = 11 total
+      assert.equal(steps.length, 11);
       // First phase should be 50 (execute-phase)
       assert.equal(steps[0].args, '50 --non-interactive');
-      // Then 50.1 (map-codebase at index 2)
-      assert.equal(steps[2].command, 'map-codebase');
-      assert.equal(steps[2].args, '50.1 --auto');
-      // Then 51 (execute-phase at index 6)
-      assert.equal(steps[6].args, '51 --non-interactive');
+      // Then 50.1 (map-codebase at index 3)
+      assert.equal(steps[3].command, 'map-codebase');
+      assert.equal(steps[3].args, '50.1 --auto');
+      // Then 51 (execute-phase at index 8)
+      assert.equal(steps[8].args, '51 --non-interactive');
     });
 
     it('includes correct flags on plan-phase (--non-interactive), execute-phase (--non-interactive), map-codebase (--auto), and audit-phase (phase number only) steps', () => {
@@ -864,11 +876,14 @@ describe('jobs', () => {
       const mapStep = steps.find(s => s.command === 'map-codebase');
       const planStep = steps.find(s => s.command === 'plan-phase');
       const executeStep = steps.find(s => s.command === 'execute-phase');
+      const validateStep = steps.find(s => s.command === 'validate-phase');
       const auditStep = steps.find(s => s.command === 'audit-phase');
 
       assert.ok(mapStep.args.includes('--auto'), 'map-codebase should have --auto');
       assert.ok(planStep.args.includes('--non-interactive'), 'plan-phase should have --non-interactive');
       assert.ok(executeStep.args.includes('--non-interactive'), 'execute-phase should have --non-interactive');
+      assert.ok(validateStep.args.includes('--scaffold'), 'validate-phase should have --scaffold');
+      assert.ok(!validateStep.args.includes('--non-interactive'), 'validate-phase should NOT have --non-interactive');
       assert.strictEqual(auditStep.args, '50', 'audit-phase should have just the phase number');
     });
 
@@ -880,12 +895,14 @@ describe('jobs', () => {
       ];
       const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
 
-      // Phase 49 complete (0 steps), Phase 50 planned (2 steps), Phase 51 planned (2 steps) = 4
-      assert.equal(steps.length, 4);
+      // Phase 49 complete (0 steps), Phase 50 planned (3 steps), Phase 51 planned (3 steps) = 6
+      assert.equal(steps.length, 6);
       assert.equal(steps[0].args, '50 --non-interactive');
-      assert.equal(steps[1].args, '50');
-      assert.equal(steps[2].args, '51 --non-interactive');
-      assert.equal(steps[3].args, '51');
+      assert.equal(steps[1].args, '50 --scaffold');
+      assert.equal(steps[2].args, '50');
+      assert.equal(steps[3].args, '51 --non-interactive');
+      assert.equal(steps[4].args, '51 --scaffold');
+      assert.equal(steps[5].args, '51');
     });
 
     it('returns steps as objects with command and args properties', () => {
@@ -929,6 +946,21 @@ describe('jobs', () => {
       }
     });
 
+    it('validate-phase steps use --scaffold flag (not --non-interactive or --auto)', () => {
+      const phases = [
+        { number: '50', name: 'Test', disk_status: 'no_directory', roadmap_complete: false },
+        { number: '51', name: 'Test2', disk_status: 'planned', roadmap_complete: false },
+      ];
+      const steps = generateMilestoneSteps(phases, { check: false, version: 'v6.0' });
+      const validateSteps = steps.filter(s => s.command === 'validate-phase');
+      assert.equal(validateSteps.length, 2, 'Should have 2 validate-phase steps');
+      for (const step of validateSteps) {
+        assert.ok(step.args.includes('--scaffold'), `validate-phase step for ${step.args} should have --scaffold`);
+        assert.ok(!step.args.includes('--auto'), 'validate-phase should NOT have --auto');
+        assert.ok(!step.args.includes('--non-interactive'), 'validate-phase should NOT have --non-interactive');
+      }
+    });
+
     it('no map-codebase for NEEDS_EXECUTION phases', () => {
       const phases = [
         { number: '50', name: 'Job Creation', disk_status: 'planned', roadmap_complete: false },
@@ -1085,7 +1117,7 @@ Plans:
       assert.equal(result.created, true);
     });
 
-    it('writes job file to jobs/pending/', () => {
+    it('writes job file to flat jobs/ directory', () => {
       fixture = createFixture({
         'ROADMAP.md': FIXTURE_ROADMAP,
         'phases/49-job-file-format/49-01-PLAN.md': '',
@@ -1097,14 +1129,14 @@ Plans:
       });
 
       const result = cmdJobsCreateMilestone(fixture.cwd, 'v6.0', true, false);
-      assert.ok(result.file.includes('pending'));
-      assert.ok(result.file.includes('milestone-v6.0.md'));
+      assert.ok(result.file.includes('jobs/milestone-v6.0.md'));
+      assert.ok(!result.file.includes('pending'), 'should write to flat jobs/ not jobs/pending/');
 
       const jobFilePath = path.join(fixture.cwd, result.file);
       assert.ok(fs.existsSync(jobFilePath), 'Job file should exist on disk');
     });
 
-    it('auto-creates jobs/pending/ directory', () => {
+    it('auto-creates jobs/ directory', () => {
       fixture = createFixture({
         'ROADMAP.md': FIXTURE_ROADMAP,
         'phases/49-job-file-format/49-01-PLAN.md': '',
@@ -1115,12 +1147,12 @@ Plans:
         'phases/50-job-creation/50-02-PLAN.md': '',
       });
 
-      // Ensure pending dir does not exist yet
-      const pendingDir = path.join(fixture.cwd, 'jobs', 'pending');
-      assert.ok(!fs.existsSync(pendingDir), 'pending dir should not exist before call');
+      // Ensure jobs dir does not exist yet
+      const jobsDir = path.join(fixture.cwd, 'jobs');
+      assert.ok(!fs.existsSync(jobsDir), 'jobs dir should not exist before call');
 
       cmdJobsCreateMilestone(fixture.cwd, 'v6.0', true, false);
-      assert.ok(fs.existsSync(pendingDir), 'pending dir should be auto-created');
+      assert.ok(fs.existsSync(jobsDir), 'jobs dir should be auto-created');
     });
 
     it('returns JSON with expected fields', () => {
@@ -2019,10 +2051,9 @@ Plans:
       if (fixture) fixture.cleanup();
     });
 
-    it('cancels in-progress job: resets [>] steps to [ ], updates Status, moves to pending/', () => {
+    it('cancels in-progress job: resets [>] steps to [ ], updates Status via frontmatter', () => {
       fixture = createFixture({
         'jobs/in-progress/milestone-v6.0.md': WELL_FORMED_JOB,
-        'jobs/pending/': null,
       });
       const result = cancelJob(fixture.cwd, 'v6.0');
 
@@ -2031,15 +2062,14 @@ Plans:
       assert.ok(result.path);
       assert.equal(result.steps_reset, 1); // one [>] step
 
-      // Verify file moved to pending
-      assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'pending', 'milestone-v6.0.md')));
-      assert.ok(!fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress', 'milestone-v6.0.md')));
+      // File stays in place — status updated via frontmatter, no file move
+      assert.ok(fs.existsSync(path.join(fixture.cwd, 'jobs', 'in-progress', 'milestone-v6.0.md')));
 
-      // Verify content: [>] reset to [ ], [x] preserved
-      const content = fs.readFileSync(path.join(fixture.cwd, 'jobs', 'pending', 'milestone-v6.0.md'), 'utf-8');
-      assert.ok(content.includes('**Status:** pending'), 'Status should be pending');
+      // Verify content: [>] reset to [ ], [x] preserved, Status header updated
+      const content = fs.readFileSync(path.join(fixture.cwd, 'jobs', 'in-progress', 'milestone-v6.0.md'), 'utf-8');
+      assert.ok(content.includes('**Status:** pending'), 'Status header should be pending');
+      assert.ok(content.includes('status: pending'), 'Frontmatter status should be pending');
       assert.ok(!content.includes('[>]'), 'No in-progress markers should remain');
-      // completed steps preserved
       assert.ok(content.includes('[x]'), 'Completed steps should be preserved');
     });
 
@@ -2071,11 +2101,11 @@ Plans:
     it('keeps completed [x] steps marked done', () => {
       fixture = createFixture({
         'jobs/in-progress/milestone-v6.0.md': WELL_FORMED_JOB,
-        'jobs/pending/': null,
       });
       cancelJob(fixture.cwd, 'v6.0');
 
-      const content = fs.readFileSync(path.join(fixture.cwd, 'jobs', 'pending', 'milestone-v6.0.md'), 'utf-8');
+      // File stays in place — read from in-progress/
+      const content = fs.readFileSync(path.join(fixture.cwd, 'jobs', 'in-progress', 'milestone-v6.0.md'), 'utf-8');
       const stepLines = content.split('\n').filter(l => l.trim().startsWith('- ['));
       const completedSteps = stepLines.filter(l => l.includes('[x]'));
       assert.ok(completedSteps.length > 0, 'Completed steps should be preserved');
@@ -2618,3 +2648,92 @@ describe('rollbackJob', () => {
     assert.equal(result.reason, 'no_start_shas');
   });
 });
+
+// ─── JOB_STATUSES constant ──────────────────────────────────────────────────
+
+describe('JOB_STATUSES constant', () => {
+  it('exports correct values', () => {
+    const { JOB_STATUSES } = require('./jobs.cjs');
+    assert.deepStrictEqual(JOB_STATUSES, ['pending', 'in-progress', 'completed', 'failed', 'rolled_back']);
+  });
+});
+
+// ─── setJobStatus ───────────────────────────────────────────────────────────
+
+describe('setJobStatus', () => {
+  it('throws on invalid status', () => {
+    const { setJobStatus } = require('./jobs.cjs');
+    assert.throws(() => {
+      setJobStatus('/nonexistent', 'v99.0', 'invalid-status');
+    }, (err) => {
+      assert.ok(err.message.includes('Invalid status'));
+      assert.ok(err.message.includes('pending'));
+      assert.ok(err.message.includes('in-progress'));
+      return true;
+    });
+  });
+});
+
+// ─── findJobFile flat-first scanning ──────────────────────────────────────
+
+describe('findJobFile flat-first scanning', () => {
+  let fixture;
+  afterEach(() => { if (fixture) fixture.cleanup(); });
+
+  it('finds job in flat jobs/ directory', () => {
+    const jobContent = '---\nstatus: pending\n---\n# Milestone Job: v20.0\n\n**Version:** v20.0\n**Created:** 2026-04-06T00:00:00Z\n**Status:** pending\n**Check:** true\n\n## Steps\n\n- [ ] `/dgs:plan-phase 132`\n';
+    fixture = createFixture({
+      'config.json': '{}',
+      'jobs/milestone-v20.0.md': jobContent,
+    });
+    const result = findJobFile(fixture.cwd, 'v20.0');
+    assert.equal(result.found, true);
+    assert.equal(result.status, 'pending');
+    assert.equal(result.directory, null, 'Flat files should have null directory');
+    assert.ok(result.path.endsWith('jobs/milestone-v20.0.md'));
+  });
+
+  it('reads status from bold-key header when no YAML frontmatter', () => {
+    const jobContent = '# Milestone Job: v19.0\n\n**Version:** v19.0\n**Created:** 2026-01-01T00:00:00Z\n**Status:** completed\n**Check:** false\n\n## Steps\n\n- [x] `/dgs:plan-phase 100` \u2014 completed\n';
+    fixture = createFixture({
+      'config.json': '{}',
+      'jobs/milestone-v19.0.md': jobContent,
+    });
+    const result = findJobFile(fixture.cwd, 'v19.0');
+    assert.equal(result.found, true);
+    assert.equal(result.status, 'completed');
+    assert.equal(result.directory, null);
+  });
+
+  it('falls back to legacy subdirectory with warning', () => {
+    const jobContent = '# Milestone Job: v18.0\n\n**Version:** v18.0\n**Created:** 2026-01-01T00:00:00Z\n**Status:** in-progress\n**Check:** true\n\n## Steps\n\n- [>] `/dgs:plan-phase 90`\n';
+    fixture = createFixture({
+      'config.json': '{}',
+      'jobs/in-progress/milestone-v18.0.md': jobContent,
+    });
+    const origWrite = process.stderr.write;
+    let stderrOutput = '';
+    process.stderr.write = (msg) => { stderrOutput += msg; };
+    try {
+      const result = findJobFile(fixture.cwd, 'v18.0');
+      assert.equal(result.found, true);
+      assert.ok(stderrOutput.includes('[DGS] Warning:'), 'Should emit legacy warning');
+      assert.ok(stderrOutput.includes('legacy'), 'Warning should mention legacy');
+      assert.equal(result.directory, 'in-progress');
+    } finally {
+      process.stderr.write = origWrite;
+    }
+  });
+
+  it('prefers flat over legacy', () => {
+    const flatJob = '---\nstatus: pending\n---\n# Milestone Job: v17.0\n\n**Version:** v17.0\n**Created:** 2026-01-01T00:00:00Z\n**Status:** pending\n**Check:** true\n\n## Steps\n\n- [ ] `/dgs:plan-phase 80`\n';
+    const legacyJob = '# Milestone Job: v17.0\n\n**Version:** v17.0\n**Created:** 2026-01-01T00:00:00Z\n**Status:** pending\n**Check:** true\n\n## Steps\n\n- [ ] `/dgs:plan-phase 80`\n';
+    fixture = createFixture({
+      'config.json': '{}',
+      'jobs/milestone-v17.0.md': flatJob,
+      'jobs/pending/milestone-v17.0.md': legacyJob,
+    });
+    const result = findJobFile(fixture.cwd, 'v17.0');
+    assert.equal(result.directory, null, 'Flat should win over legacy');
+  });
+});