qualia-framework 3.6.0 → 4.0.0

package/tests/runner.js

@@ -835,9 +835,11 @@ waves: 1
   it("init --force overwrites an existing project (preserves lifetime)", () => {
     const tmpDir = makeProject();
     try {
-      // Seed lifetime via close-milestone first
+      // Seed lifetime via close-milestone first. --force bypasses the v4
+      // readiness guards (MILESTONE_NOT_READY) since this test doesn't
+      // exercise the verification flow — it's focused on lifetime preservation.
       const c = spawnSync(process.execPath, [
-        path.join(BIN, "state.js"), "close-milestone",
+        path.join(BIN, "state.js"), "close-milestone", "--force",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       assert.equal(c.status, 0);
       const tBefore = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
@@ -863,8 +865,10 @@ waves: 1
   it("close-milestone refuses double-close (idempotency)", () => {
     const tmpDir = makeProject();
     try {
+      // First close uses --force to bypass v4 readiness guards — this test
+      // focuses on the ALREADY_CLOSED sentinel, not phase-verification gates.
       const r1 = spawnSync(process.execPath, [
-        path.join(BIN, "state.js"), "close-milestone",
+        path.join(BIN, "state.js"), "close-milestone", "--force",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       assert.equal(r1.status, 0);
       const out1 = JSON.parse(r1.stdout);
@@ -878,6 +882,8 @@ waves: 1
       t.milestone = out1.closed_milestone; // rewind
       fs.writeFileSync(tFile, JSON.stringify(t, null, 2) + "\n");
 
+      // Second close (without --force) must fail with ALREADY_CLOSED, which
+      // is checked BEFORE the readiness guards in cmdCloseMilestone.
       const r2 = spawnSync(process.execPath, [
         path.join(BIN, "state.js"), "close-milestone",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
@@ -893,7 +899,7 @@ waves: 1
     const tmpDir = makeProject();
     try {
       const r1 = spawnSync(process.execPath, [
-        path.join(BIN, "state.js"), "close-milestone",
+        path.join(BIN, "state.js"), "close-milestone", "--force",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       assert.equal(r1.status, 0);
 
@@ -1002,6 +1008,165 @@ waves: 1
     }
   });
 
+  // ─── v4.0.0: milestone readiness guards + milestones[] summary ─
+  it("close-milestone refuses unverified phases (MILESTONE_NOT_READY)", () => {
+    const tmpDir = makeProject();
+    try {
+      // No phases verified yet — close-milestone (without --force) must refuse.
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 1);
+      const out = JSON.parse(r.stdout);
+      assert.equal(out.error, "MILESTONE_NOT_READY");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("close-milestone refuses single-phase milestones (MILESTONE_TOO_SMALL)", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-single-"));
+    try {
+      const init = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "init",
+        "--project", "SingleProject",
+        "--phases", '[{"name":"Only","goal":"Y"}]',
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(init.status, 0);
+
+      // Single-phase milestone — even if the phase were verified, the size
+      // guard catches it first. A milestone needs ≥ 2 phases without --force.
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 1);
+      const out = JSON.parse(r.stdout);
+      assert.equal(out.error, "MILESTONE_TOO_SMALL");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("close-milestone appends a summary to milestones[]", () => {
+    const tmpDir = makeProject();
+    try {
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone", "--force",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const t = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      assert.ok(Array.isArray(t.milestones), "milestones[] must exist");
+      assert.equal(t.milestones.length, 1);
+      const m1 = t.milestones[0];
+      assert.equal(m1.num, 1);
+      assert.ok(m1.total_phases >= 2, "total_phases should reflect seeded phases");
+      assert.ok(typeof m1.closed_at === "string" && m1.closed_at.length > 0);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("milestone summary captures cumulative tasks_completed, not current phase only", () => {
+    const tmpDir = makeProject();
+    try {
+      // Simulate 2 phases each with 3 tasks verified pass. This bumps
+      // lifetime.tasks_completed to 6. The milestone close summary should
+      // reflect 6, not just 3 (the last phase's tasks_done).
+      for (const phase of [1, 2]) {
+        const planFile = path.join(tmpDir, ".planning", `phase-${phase}-plan.md`);
+        fs.writeFileSync(planFile, `---
+phase: ${phase}
+goal: "x"
+tasks: 1
+waves: 1
+---
+
+## Task 1 — x
+**Wave:** 1
+**Files:** x.ts
+**Depends on:** none
+**Acceptance Criteria:**
+- ok
+`);
+        const verFile = path.join(tmpDir, ".planning", `phase-${phase}-verification.md`);
+        // Plan → built → verified
+        let r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "planned", "--phase", String(phase)],
+          { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        assert.equal(r.status, 0, `planned transition failed for phase ${phase}: ${r.stderr || r.stdout}`);
+        r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "built", "--phase", String(phase), "--tasks-done", "3", "--tasks-total", "3"],
+          { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        assert.equal(r.status, 0, `built transition failed for phase ${phase}: ${r.stderr || r.stdout}`);
+        fs.writeFileSync(verFile, "result: PASS");
+        r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "verified", "--phase", String(phase), "--verification", "pass"],
+          { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        assert.equal(r.status, 0, `verified transition failed for phase ${phase}: ${r.stderr || r.stdout}`);
+      }
+
+      // Close milestone
+      const r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "close-milestone"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0, `close-milestone failed: ${r.stderr || r.stdout}`);
+
+      const t = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(t.lifetime.tasks_completed, 6, "lifetime should have 6 tasks (2 phases × 3 tasks)");
+      assert.equal(t.milestones.length, 1);
+      assert.equal(t.milestones[0].tasks_completed, 6, "milestone summary should cumulate all 6 tasks, not just the last phase's 3");
+      assert.equal(t.milestones[0].phases_completed, 2);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("build_count bumps on each 'built' transition", () => {
+    const tmpDir = makeProject();
+    try {
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const before = JSON.parse(fs.readFileSync(tFile, "utf8")).build_count || 0;
+
+      fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-plan.md"), `---
+phase: 1
+goal: "x"
+tasks: 1
+waves: 1
+---
+
+## Task 1 — x
+**Wave:** 1
+**Files:** x.ts
+**Depends on:** none
+**Acceptance Criteria:**
+- ok
+`);
+      spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "planned", "--phase", "1"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      const r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "built", "--phase", "1", "--tasks-done", "1", "--tasks-total", "1"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+
+      const after = JSON.parse(fs.readFileSync(tFile, "utf8")).build_count || 0;
+      assert.equal(after, before + 1, "build_count should bump on 'built' transition");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("check exposes milestones[] and milestone_name in output", () => {
+    const tmpDir = makeProject();
+    try {
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "check",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+      const out = JSON.parse(r.stdout);
+      assert.ok(Array.isArray(out.milestones), "check must expose milestones[]");
+      assert.ok(typeof out.milestone_name === "string", "check must expose milestone_name");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
   // ─── v3.5.0: CRLF tolerance in parseStateMd ────────────
   it("parseStateMd tolerates CRLF line endings (Windows-edited STATE.md)", () => {
     const tmpDir = makeProject();