qualia-framework 4.0.0 → 4.0.5

package/tests/runner.js

@@ -1198,6 +1198,194 @@ waves: 1
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
+
+  // ─── v4 regression: deploy_count actually increments on shipped ───
+  it("transition --to shipped increments deploy_count", () => {
+    const tmpDir = makeProject();
+    try {
+      // Walk both phases through verified, then polished, then shipped.
+      makeValidPlan(tmpDir, 1);
+      runState(["transition", "--to", "planned"], tmpDir);
+      runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
+      fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "# pass\n");
+      runState(["transition", "--to", "verified", "--verification", "pass"], tmpDir);
+
+      makeValidPlan(tmpDir, 2);
+      runState(["transition", "--to", "planned"], tmpDir);
+      runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
+      fs.writeFileSync(path.join(tmpDir, ".planning", "phase-2-verification.md"), "# pass\n");
+      runState(["transition", "--to", "verified", "--verification", "pass"], tmpDir);
+      runState(["transition", "--to", "polished"], tmpDir);
+
+      const before = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(parseInt(before.deploy_count) || 0, 0, "deploy_count starts at 0");
+
+      const r = runState(["transition", "--to", "shipped", "--deployed-url", "https://x.test"], tmpDir);
+      assert.equal(r.status, 0, `shipped transition failed: ${r.stdout} ${r.stderr}`);
+      const after = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(parseInt(after.deploy_count), 1, "deploy_count must increment to 1");
+      assert.equal(after.deployed_url, "https://x.test");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4.0.2: write-ahead journal recovery ─────────────────
+  // Simulate a crashed previous mutator by dropping a .state.journal file
+  // with pre-transition snapshots of STATE.md and tracking.json. The next
+  // mutator invocation must restore both files from the journal and remove it.
+  it("recovers STATE.md + tracking.json from .state.journal on next mutator", () => {
+    const tmpDir = makeProject();
+    try {
+      const statePath = path.join(tmpDir, ".planning", "STATE.md");
+      const trackPath = path.join(tmpDir, ".planning", "tracking.json");
+      const journalPath = path.join(tmpDir, ".planning", ".state.journal");
+
+      const origState = fs.readFileSync(statePath, "utf8");
+      const origTracking = fs.readFileSync(trackPath, "utf8");
+
+      // Corrupt STATE.md and tracking.json to simulate a half-completed write.
+      fs.writeFileSync(statePath, "# CORRUPTED\n");
+      fs.writeFileSync(trackPath, '{"corrupt":true}\n');
+
+      // Drop a journal that would have been written before the corruption.
+      fs.writeFileSync(journalPath, JSON.stringify({
+        ts: new Date().toISOString(),
+        pid: 99999,
+        state: origState,
+        tracking: origTracking,
+      }));
+
+      // Any mutator should trigger recovery. Use `fix` (a cheap mutator).
+      const r = runState(["fix"], tmpDir);
+      // Not asserting r.status — fix may succeed or report nothing to fix.
+      // What matters: STATE.md and tracking.json were restored and journal is gone.
+      assert.equal(fs.existsSync(journalPath), false, "journal must be removed after recovery");
+      const recoveredState = fs.readFileSync(statePath, "utf8");
+      const recoveredTracking = fs.readFileSync(trackPath, "utf8");
+      assert.ok(recoveredState.includes("Current Position") || recoveredState === origState,
+        "STATE.md must be restored from journal");
+      assert.notStrictEqual(recoveredTracking, '{"corrupt":true}\n',
+        "tracking.json must no longer be the corrupted snapshot");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4.0.2: corrupt journal is tolerated, not fatal ──────
+  it("corrupt .state.journal is cleared without crashing mutator", () => {
+    const tmpDir = makeProject();
+    try {
+      const journalPath = path.join(tmpDir, ".planning", ".state.journal");
+      fs.writeFileSync(journalPath, "{not valid json");
+      const r = runState(["check"], tmpDir);
+      // check is read-only so it won't recover; use a mutator.
+      runState(["fix"], tmpDir);
+      assert.equal(fs.existsSync(journalPath), false,
+        "corrupt journal must be cleaned up so we don't loop on recovery");
+      assert.equal(r.status, 0, "check should still work with a stray journal file");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4.0.4: next-report-id ────────────────────────────────
+  it("next-report-id returns QS-REPORT-01 on fresh project and increments", () => {
+    const tmpDir = makeProject();
+    try {
+      const r1 = spawnSync(process.execPath,
+        [path.join(BIN, "state.js"), "next-report-id"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r1.status, 0, `next-report-id failed: ${r1.stderr || r1.stdout}`);
+      const j1 = JSON.parse(r1.stdout);
+      assert.equal(j1.report_id, "QS-REPORT-01");
+      assert.equal(j1.report_seq, 1);
+      assert.equal(j1.peeked, false);
+
+      const r2 = spawnSync(process.execPath,
+        [path.join(BIN, "state.js"), "next-report-id"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      const j2 = JSON.parse(r2.stdout);
+      assert.equal(j2.report_id, "QS-REPORT-02");
+      assert.equal(j2.report_seq, 2);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("next-report-id --peek does NOT increment the counter", () => {
+    const tmpDir = makeProject();
+    try {
+      const r1 = spawnSync(process.execPath,
+        [path.join(BIN, "state.js"), "next-report-id", "--peek"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      const j1 = JSON.parse(r1.stdout);
+      assert.equal(j1.report_id, "QS-REPORT-01");
+      assert.equal(j1.peeked, true);
+
+      // Peek again — should still return QS-REPORT-01 since nothing incremented
+      const r2 = spawnSync(process.execPath,
+        [path.join(BIN, "state.js"), "next-report-id", "--peek"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      const j2 = JSON.parse(r2.stdout);
+      assert.equal(j2.report_id, "QS-REPORT-01");
+      assert.equal(j2.report_seq, 1);
+
+      // On-disk report_seq should still be 0
+      const t = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.ok(!t.report_seq || t.report_seq === 0,
+        `report_seq should remain 0 after peek, got ${t.report_seq}`);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4.0.4: close-milestone pre-populates next milestone_name from JOURNEY.md
+  it("close-milestone pre-populates next milestone_name from JOURNEY.md", () => {
+    const tmpDir = makeProject();
+    try {
+      // Write JOURNEY.md with Milestone 2 definition
+      fs.writeFileSync(path.join(tmpDir, ".planning", "JOURNEY.md"), `# Journey
+
+## Milestone 1 · Foundation     [CURRENT]
+Exit: scaffolding done
+
+## Milestone 2 · Core Features
+Exit: auth + dashboard
+
+## Milestone 3 · Handoff     [FINAL]
+Exit: client takeover
+`);
+      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, `close-milestone failed: ${r.stderr || r.stdout}`);
+
+      const t = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(t.milestone, 2);
+      assert.equal(t.milestone_name, "Core Features",
+        `milestone_name should be pre-populated from JOURNEY.md, got '${t.milestone_name}'`);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("close-milestone leaves milestone_name blank when JOURNEY.md is missing", () => {
+    const tmpDir = makeProject();
+    try {
+      // No JOURNEY.md — milestone_name should fall back to blank (legacy behavior)
+      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 t = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(t.milestone_name, "",
+        "milestone_name must be blank when JOURNEY.md is absent (fallback unchanged)");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });
 
 // ═══════════════════════════════════════════════════════════
@@ -1455,7 +1643,7 @@ describe("Hooks", () => {
       const r = spawnSync(process.execPath, [path.join(HOOKS, "pre-deploy-gate.js")], {
         encoding: "utf8", cwd: tmpDir, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 1);
+      assert.equal(r.status, 2, "PreToolUse hook must exit 2 to block");
       const combined = r.stdout + r.stderr;
       assert.match(combined, /BLOCKED/);
       assert.match(combined, /service_role/);
@@ -1472,7 +1660,7 @@ describe("Hooks", () => {
       const r = spawnSync(process.execPath, [path.join(HOOKS, "pre-deploy-gate.js")], {
         encoding: "utf8", cwd: tmpDir, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 1);
+      assert.equal(r.status, 2, "PreToolUse hook must exit 2 to block");
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -1607,7 +1795,7 @@ describe("Hooks", () => {
       const r = spawnSync(process.execPath, [path.join(HOOKS, "pre-deploy-gate.js")], {
         encoding: "utf8", cwd: tmpDir, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 1);
+      assert.equal(r.status, 2, "PreToolUse hook must exit 2 to block");
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -1843,6 +2031,28 @@ describe("Hooks", () => {
     assert.equal(r.status, 2, "UPDATE without WHERE must block");
   });
 
+  // v4.0.2: per-statement scan (previously a WHERE in ANY later statement
+  // made an unsafe DELETE pass).
+  it("migration-guard: DELETE FROM followed by unrelated SELECT WHERE -> blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: {
+        file_path: "supabase/migrations/004b.sql",
+        content: "DELETE FROM users;\nSELECT * FROM logs WHERE ts > NOW();",
+      },
+    });
+    assert.equal(r.status, 2, "per-statement scan must still catch the DELETE without WHERE");
+  });
+
+  it("migration-guard: UPDATE SET without WHERE followed by unrelated WHERE -> blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: {
+        file_path: "supabase/migrations/004c.sql",
+        content: "UPDATE accounts SET active = true;\nSELECT id FROM sessions WHERE expires > NOW();",
+      },
+    });
+    assert.equal(r.status, 2, "per-statement scan must catch the UPDATE without WHERE");
+  });
+
   it("migration-guard: GRANT TO PUBLIC -> blocked", () => {
     const r = runHook("migration-guard.js", {
       tool_input: { file_path: "supabase/migrations/005.sql", content: "GRANT ALL ON users TO PUBLIC;" },
@@ -2232,6 +2442,63 @@ describe("qualia-ui.js", () => {
       fs.rmSync(tmpHome, { recursive: true, force: true });
     }
   });
+
+  // ─── v4 regression: journey-tree renders without crashing ───
+  // Previously crashed with "Cannot access 'projectName' before initialization"
+  // because a const shadowed the fallback function inside its own initializer.
+  it("journey-tree renders milestones without crashing", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-jt-"));
+    try {
+      fs.mkdirSync(path.join(tmpDir, ".planning"), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "JOURNEY.md"),
+        "# JOURNEY\n\n## Milestone 1 · Foundation\n\nWhy now.\n\n## Milestone 2 · Handoff\n\nDeliver.\n"
+      );
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "tracking.json"),
+        JSON.stringify({ project: "jtproj", milestone: 1, milestones: [] })
+      );
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "STATE.md"),
+        "---\nproject: jtproj\nphase: 1\nstatus: planning\nmilestone: 1\n---\n"
+      );
+      const r = runUI(["journey-tree"], { cwd: tmpDir, home: tmpDir });
+      assert.equal(r.status, 0, `journey-tree crashed: ${r.stderr}`);
+      const clean = stripAnsi(r.stdout);
+      assert.match(clean, /JOURNEY/);
+      assert.match(clean, /M1 · Foundation/);
+      assert.match(clean, /M2 · Handoff/);
+      assert.match(clean, /\[CURRENT\]/);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4 regression: journey-tree uses projectName() fallback when frontmatter missing ───
+  // Would previously throw ReferenceError because `const projectName` shadowed the
+  // function name inside its own initializer. Fallback resolves to basename(cwd).
+  it("journey-tree uses projectName() fallback when no project: in JOURNEY frontmatter", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-jt-fallback-"));
+    try {
+      fs.mkdirSync(path.join(tmpDir, ".planning"), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "JOURNEY.md"),
+        "# JOURNEY\n\n## Milestone 1 · Foundation\n\nWhy now.\n\n## Milestone 2 · Handoff\n\nLast.\n"
+      );
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "tracking.json"),
+        JSON.stringify({ project: "ignored-by-fallback", milestone: 1 })
+      );
+      const r = runUI(["journey-tree"], { cwd: tmpDir, home: tmpDir });
+      assert.equal(r.status, 0, `journey-tree crashed: ${r.stderr}`);
+      const clean = stripAnsi(r.stdout);
+      // Fallback is path.basename(cwd) — whatever the tmp dir is named.
+      assert.match(clean, new RegExp(path.basename(tmpDir)));
+      assert.match(clean, /M1 · Foundation/);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });
 
 // ═══════════════════════════════════════════════════════════
@@ -2440,6 +2707,46 @@ describe("install.js", () => {
     }
   });
 
+  // v4.0.2: reinstall merges hooks instead of clobbering.
+  it("re-install preserves user-added hooks in settings.json", () => {
+    const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-install-"));
+    try {
+      // Fresh install first, then inject a user-owned hook, then reinstall.
+      runInstall("QS-FAWZI-01", tmpHome);
+      const settingsPath = path.join(tmpHome, ".claude", "settings.json");
+      const before = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+
+      // Add a user hook to PreToolUse that is not a Qualia command.
+      const userHook = {
+        matcher: "Bash",
+        hooks: [
+          { type: "command", command: "echo user-owned-pre-tool-hook", timeout: 3 },
+        ],
+      };
+      before.hooks.PreToolUse = [userHook, ...(before.hooks.PreToolUse || [])];
+      fs.writeFileSync(settingsPath, JSON.stringify(before, null, 2));
+
+      const r = runInstall("QS-FAWZI-01", tmpHome);
+      assert.equal(r.status, 0);
+      const after = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      const allCmds = [];
+      for (const block of after.hooks.PreToolUse || []) {
+        for (const h of (block.hooks || [])) allCmds.push(String(h.command || ""));
+      }
+      assert.ok(
+        allCmds.some((c) => c.includes("user-owned-pre-tool-hook")),
+        `user hook was clobbered by reinstall. Commands: ${allCmds.join(" | ")}`
+      );
+      // And Qualia hooks should still be there.
+      assert.ok(
+        allCmds.some((c) => c.includes("branch-guard.js")),
+        "Qualia hooks must still be present after reinstall"
+      );
+    } finally {
+      fs.rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
   it("templates copied to qualia-templates/", () => {
     const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-install-"));
     try {