qualia-framework 3.3.2 → 3.6.0

package/tests/runner.js

@@ -814,6 +814,225 @@ waves: 1
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
+
+  // ─── v3.4.2: init guard ────────────────────────────────
+  it("init refuses to clobber an existing project (no --force)", () => {
+    const tmpDir = makeProject();
+    try {
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "init",
+        "--project", "TestProject",
+        "--phases", '[{"name":"X","goal":"Y"}]',
+      ], { 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, "ALREADY_INITIALIZED");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("init --force overwrites an existing project (preserves lifetime)", () => {
+    const tmpDir = makeProject();
+    try {
+      // Seed lifetime via close-milestone first
+      const c = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { 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"));
+      assert.ok(tBefore.lifetime.milestones_completed >= 1);
+
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "init",
+        "--project", "TestProject",
+        "--phases", '[{"name":"NewFoundation","goal":"X"}]',
+        "--force",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+      const tAfter = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(tAfter.lifetime.milestones_completed, tBefore.lifetime.milestones_completed);
+      assert.equal(tAfter.phase, 1);
+      assert.equal(tAfter.status, "setup");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v3.4.2: close-milestone idempotency ───────────────
+  it("close-milestone refuses double-close (idempotency)", () => {
+    const tmpDir = makeProject();
+    try {
+      const r1 = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r1.status, 0);
+      const out1 = JSON.parse(r1.stdout);
+      assert.equal(out1.lifetime.milestones_completed, 1);
+
+      // Manually rewind milestone counter to simulate a re-run on the same closed milestone.
+      // (Real close-milestone advances t.milestone, so a true double-close requires
+      // putting milestone back to its prior value.)
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const t = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      t.milestone = out1.closed_milestone; // rewind
+      fs.writeFileSync(tFile, JSON.stringify(t, null, 2) + "\n");
+
+      const r2 = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r2.status, 1);
+      const out2 = JSON.parse(r2.stdout);
+      assert.equal(out2.error, "ALREADY_CLOSED");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("close-milestone --force allows re-close", () => {
+    const tmpDir = makeProject();
+    try {
+      const r1 = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r1.status, 0);
+
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const t = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      t.milestone = JSON.parse(r1.stdout).closed_milestone;
+      fs.writeFileSync(tFile, JSON.stringify(t, null, 2) + "\n");
+
+      const r2 = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone", "--force",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r2.status, 0);
+      const out2 = JSON.parse(r2.stdout);
+      assert.equal(out2.lifetime.milestones_completed, 2);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v3.4.2: backfill never reduces lifetime (Math.max) ─
+  it("backfill-lifetime never reduces existing counters", () => {
+    const tmpDir = makeProject();
+    try {
+      // Seed lifetime with high values (simulating prior close-milestone)
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const t = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      t.lifetime.tasks_completed = 100;
+      t.lifetime.phases_completed = 20;
+      fs.writeFileSync(tFile, JSON.stringify(t, null, 2) + "\n");
+
+      // Backfill on a project with NO completed phases would compute 0/0
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "backfill-lifetime",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+      const tAfter = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      assert.equal(tAfter.lifetime.tasks_completed, 100, "backfill must NOT reduce tasks_completed");
+      assert.equal(tAfter.lifetime.phases_completed, 20, "backfill must NOT reduce phases_completed");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v3.4.2: atomic write leaves no .tmp file ──────────
+  it("transition leaves no .tmp file on success (atomic write)", () => {
+    const tmpDir = makeProject();
+    try {
+      makeValidPlan(tmpDir, 1);
+      const r = runState(["transition", "--to", "planned"], tmpDir);
+      assert.equal(r.status, 0);
+      const planning = path.join(tmpDir, ".planning");
+      const tmps = fs.readdirSync(planning).filter(f => f.includes(".tmp."));
+      assert.equal(tmps.length, 0, `Stale .tmp files: ${tmps.join(", ")}`);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v3.6.0: tracking.json schema additions ────────────
+  it("init writes new schema fields (team_id, project_id, build_count, etc.)", () => {
+    const tmpDir = makeProject();
+    try {
+      const t = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      // New v3.6 fields (default to empty / 0, but must be present)
+      assert.ok("team_id" in t, "team_id missing");
+      assert.ok("project_id" in t, "project_id missing");
+      assert.ok("git_remote" in t, "git_remote missing");
+      assert.ok("session_started_at" in t, "session_started_at missing");
+      assert.ok("last_pushed_at" in t, "last_pushed_at missing");
+      assert.ok("build_count" in t, "build_count missing");
+      assert.ok("deploy_count" in t, "deploy_count missing");
+      assert.ok("submitted_by" in t, "submitted_by missing");
+      assert.ok("last_closed_milestone" in t.lifetime, "lifetime.last_closed_milestone missing");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("init --force defensively hydrates partial lifetime (no NaN)", () => {
+    const tmpDir = makeProject();
+    try {
+      // Write a partial lifetime that's missing keys
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const t = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      t.lifetime = { tasks_completed: 5 }; // partial — missing other keys
+      fs.writeFileSync(tFile, JSON.stringify(t, null, 2) + "\n");
+
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "init",
+        "--project", "TestProject",
+        "--phases", '[{"name":"X","goal":"Y"}]',
+        "--force",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+      const tAfter = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      // Original partial value preserved
+      assert.equal(tAfter.lifetime.tasks_completed, 5);
+      // Missing keys defaulted to 0, never NaN
+      assert.equal(tAfter.lifetime.phases_completed, 0);
+      assert.equal(tAfter.lifetime.milestones_completed, 0);
+      assert.equal(tAfter.lifetime.total_phases, 0);
+      assert.equal(tAfter.lifetime.last_closed_milestone, 0);
+      assert.ok(!Number.isNaN(tAfter.lifetime.phases_completed));
+    } 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();
+    try {
+      const stateFile = path.join(tmpDir, ".planning", "STATE.md");
+      const lf = fs.readFileSync(stateFile, "utf8");
+      // Simulate Windows editor save: convert all \n to \r\n
+      const crlf = lf.replace(/\n/g, "\r\n");
+      fs.writeFileSync(stateFile, crlf);
+      const r = runState(["check"], tmpDir);
+      assert.equal(r.status, 0, `check failed on CRLF STATE.md: ${r.stdout} ${r.stderr}`);
+      const out = JSON.parse(r.stdout);
+      assert.equal(out.phase_name, "Foundation", "phase_name must NOT contain trailing \\r");
+      assert.equal(out.status, "setup", "status must NOT contain trailing \\r");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v3.4.2: lock file is released after mutation ──────
+  it("transition releases the .state.lock", () => {
+    const tmpDir = makeProject();
+    try {
+      makeValidPlan(tmpDir, 1);
+      runState(["transition", "--to", "planned"], tmpDir);
+      const lockExists = fs.existsSync(path.join(tmpDir, ".planning", ".state.lock"));
+      assert.equal(lockExists, false, "lock file should be released after transition");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });
 
 // ═══════════════════════════════════════════════════════════
@@ -912,6 +1131,53 @@ describe("Hooks", () => {
     assert.match(content, /last_commit/);
   });
 
+  // v3.4.2: behavioral test — the stamp must actually mutate tracking.json
+  // AND create a real commit so the push includes it.
+  it("pre-push.js mutates tracking.json AND commits the stamp", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-push-real-"));
+    try {
+      // Init a real git repo
+      const gitOpts = { cwd: tmpDir, encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] };
+      spawnSync("git", ["init", "--initial-branch=main"], gitOpts);
+      spawnSync("git", ["config", "user.email", "test@example.com"], gitOpts);
+      spawnSync("git", ["config", "user.name", "Test"], gitOpts);
+      spawnSync("git", ["config", "commit.gpgsign", "false"], gitOpts);
+
+      // Seed .planning/tracking.json + an initial commit
+      fs.mkdirSync(path.join(tmpDir, ".planning"));
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      fs.writeFileSync(tFile, JSON.stringify({
+        project: "test", phase: 1, status: "setup", last_commit: "OLD", last_updated: "2020-01-01T00:00:00Z",
+      }, null, 2) + "\n");
+      spawnSync("git", ["add", "."], gitOpts);
+      spawnSync("git", ["commit", "-m", "seed", "--no-verify"], gitOpts);
+
+      const headBefore = spawnSync("git", ["rev-parse", "HEAD"], gitOpts).stdout.trim();
+
+      // Run the hook
+      const r = spawnSync(process.execPath, [path.join(HOOKS, "pre-push.js")], {
+        encoding: "utf8", cwd: tmpDir, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
+      });
+      assert.equal(r.status, 0, `pre-push exited ${r.status}: ${r.stderr}`);
+
+      // tracking.json must have been mutated
+      const t = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      assert.notEqual(t.last_commit, "OLD", "last_commit should have been updated");
+      assert.notEqual(t.last_updated, "2020-01-01T00:00:00Z", "last_updated should have been updated");
+      assert.match(t.last_updated, /^\d{4}-\d{2}-\d{2}T/);
+
+      // A NEW commit must exist (this is the smoking-gun fix from v3.4.2)
+      const headAfter = spawnSync("git", ["rev-parse", "HEAD"], gitOpts).stdout.trim();
+      assert.notEqual(headAfter, headBefore, "pre-push must commit the stamp so it ships with the push");
+
+      // The new commit must be authored by the bot, not the user
+      const author = spawnSync("git", ["log", "-1", "--format=%an <%ae>"], gitOpts).stdout.trim();
+      assert.match(author, /Qualia Framework/);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
   it("pre-push.js exits 0 with no tracking.json", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-push-"));
     try {
@@ -1303,6 +1569,135 @@ describe("Hooks", () => {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
+
+  // v3.5.0: refspec bypass — EMPLOYEE on a feature branch trying to push
+  // `feature/x:main` MUST be blocked, even though current branch isn't main.
+  it("branch-guard: EMPLOYEE refspec push to main -> blocked", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
+    try {
+      const projDir = path.join(tmpDir, "proj");
+      fs.mkdirSync(projDir, { recursive: true });
+      fs.mkdirSync(path.join(tmpDir, ".claude"), { recursive: true });
+      spawnSync("git", ["init", "-q"], { cwd: projDir });
+      spawnSync("git", ["checkout", "-b", "feature/x", "-q"], { cwd: projDir, stdio: "pipe" });
+      fs.writeFileSync(path.join(tmpDir, ".claude", ".qualia-config.json"), JSON.stringify({ role: "EMPLOYEE" }));
+      // Send Claude Code hook payload via stdin
+      const payload = JSON.stringify({
+        tool_input: { command: "git push origin feature/x:main" },
+      });
+      const r = spawnSync(process.execPath, [path.join(HOOKS, "branch-guard.js")], {
+        encoding: "utf8", cwd: projDir, timeout: 5000,
+        env: { ...process.env, HOME: tmpDir, USERPROFILE: tmpDir },
+        input: payload,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      assert.equal(r.status, 2, "refspec push to main must be blocked for EMPLOYEE");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("branch-guard: EMPLOYEE refspec push to master -> blocked", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
+    try {
+      const projDir = path.join(tmpDir, "proj");
+      fs.mkdirSync(projDir, { recursive: true });
+      fs.mkdirSync(path.join(tmpDir, ".claude"), { recursive: true });
+      spawnSync("git", ["init", "-q"], { cwd: projDir });
+      spawnSync("git", ["checkout", "-b", "feature/x", "-q"], { cwd: projDir, stdio: "pipe" });
+      fs.writeFileSync(path.join(tmpDir, ".claude", ".qualia-config.json"), JSON.stringify({ role: "EMPLOYEE" }));
+      const payload = JSON.stringify({
+        tool_input: { command: "git push origin HEAD:master" },
+      });
+      const r = spawnSync(process.execPath, [path.join(HOOKS, "branch-guard.js")], {
+        encoding: "utf8", cwd: projDir, timeout: 5000,
+        env: { ...process.env, HOME: tmpDir, USERPROFILE: tmpDir },
+        input: payload,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      assert.equal(r.status, 2, "refspec push to master must be blocked for EMPLOYEE");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("branch-guard: OWNER refspec push to main -> allowed", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
+    try {
+      const projDir = path.join(tmpDir, "proj");
+      fs.mkdirSync(projDir, { recursive: true });
+      fs.mkdirSync(path.join(tmpDir, ".claude"), { recursive: true });
+      spawnSync("git", ["init", "-q"], { cwd: projDir });
+      spawnSync("git", ["checkout", "-b", "feature/x", "-q"], { cwd: projDir, stdio: "pipe" });
+      fs.writeFileSync(path.join(tmpDir, ".claude", ".qualia-config.json"), JSON.stringify({ role: "OWNER" }));
+      const payload = JSON.stringify({
+        tool_input: { command: "git push origin feature/x:main" },
+      });
+      const r = spawnSync(process.execPath, [path.join(HOOKS, "branch-guard.js")], {
+        encoding: "utf8", cwd: projDir, timeout: 5000,
+        env: { ...process.env, HOME: tmpDir, USERPROFILE: tmpDir },
+        input: payload,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      assert.equal(r.status, 0, "OWNER may push to main via refspec");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // v3.5.0: migration-guard — comments stripped before pattern match
+  it("migration-guard: commented-out DROP TABLE is NOT blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: {
+        file_path: "supabase/migrations/001_init.sql",
+        content: "-- DROP TABLE old_users; (rolled back, kept for reference)\nCREATE TABLE foo (id uuid) WITH (security_invoker = true);\nALTER TABLE foo ENABLE ROW LEVEL SECURITY;",
+      },
+    });
+    assert.equal(r.status, 0, `commented DROP should not block: ${r.stdout || r.stderr}`);
+  });
+
+  // v3.5.0: migration-guard — new destructive patterns
+  it("migration-guard: ALTER TABLE DROP COLUMN -> blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: { file_path: "supabase/migrations/002.sql", content: "ALTER TABLE users DROP COLUMN ssn;" },
+    });
+    assert.equal(r.status, 2, "ALTER TABLE DROP COLUMN must block");
+  });
+
+  it("migration-guard: DROP DATABASE -> blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: { file_path: "supabase/migrations/003.sql", content: "DROP DATABASE production;" },
+    });
+    assert.equal(r.status, 2, "DROP DATABASE must block");
+  });
+
+  it("migration-guard: UPDATE without WHERE -> blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: { file_path: "supabase/migrations/004.sql", content: "UPDATE users SET email = NULL;" },
+    });
+    assert.equal(r.status, 2, "UPDATE without WHERE must block");
+  });
+
+  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;" },
+    });
+    assert.equal(r.status, 2, "GRANT TO PUBLIC must block");
+  });
+
+  it("migration-guard: CREATE TEMP TABLE without RLS -> NOT blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: { file_path: "supabase/migrations/006.sql", content: "CREATE TEMP TABLE scratch (id int);" },
+    });
+    assert.equal(r.status, 0, "TEMP tables should be exempt from the RLS requirement");
+  });
+
+  it("migration-guard: MigrationModal.tsx is NOT scanned", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: { file_path: "src/components/MigrationModal.tsx", content: "DROP TABLE users;" },
+    });
+    assert.equal(r.status, 0, "files with 'migration' in the name but not in a migrations/ dir should not be scanned");
+  });
 });
 
 // ═══════════════════════════════════════════════════════════

package/tests/state.test.sh

@@ -695,18 +695,246 @@ else
   fail_case "force vs MISSING_FILE" "exit=$EXIT out=$OUT"
 fi
 
-# 38. --force does NOT bypass INVALID_PLAN
+# 38. --force DOES bypass INVALID_PLAN (added in v3.3.2 for retroactive bookkeeping)
 TMP=$(make_project)
 echo "# No tasks here" > "$TMP/.planning/phase-1-plan.md"
 OUT=$(cd "$TMP" && $NODE "$STATE_JS" transition --to planned --force 2>&1)
 EXIT=$?
-if [ "$EXIT" -eq 1 ] \
-   && echo "$OUT" | grep -q '"error": "INVALID_PLAN"'; then
-  pass "--force does NOT bypass INVALID_PLAN"
+if [ "$EXIT" -eq 0 ] \
+   && echo "$OUT" | grep -q '"ok": true' \
+   && echo "$OUT" | grep -q '"status": "planned"'; then
+  pass "--force bypasses INVALID_PLAN (v3.3.2 behavior)"
 else
   fail_case "force vs INVALID_PLAN" "exit=$EXIT out=$OUT"
 fi
 
+# ─── Lifetime tracking ───────────────────────────────────
+echo ""
+echo "lifetime tracking:"
+
+# 39. cmdInit preserves lifetime fields from existing tracking.json
+TMP=$(make_project)
+# Inject lifetime data into existing tracking.json
+$NODE -e "
+  const t = JSON.parse(require('fs').readFileSync('$TMP/.planning/tracking.json','utf8'));
+  t.milestone = 2;
+  t.lifetime = { tasks_completed: 50, phases_completed: 6, milestones_completed: 1, total_phases: 6 };
+  require('fs').writeFileSync('$TMP/.planning/tracking.json', JSON.stringify(t, null, 2));
+"
+# Re-init (simulating milestone transition)
+(cd "$TMP" && $NODE "$STATE_JS" init \
+  --project "TestProject" \
+  --phases '[{"name":"NewP1","goal":"G1"},{"name":"NewP2","goal":"G2"},{"name":"NewP3","goal":"G3"}]' \
+  >/dev/null 2>&1)
+if grep -q '"tasks_completed": 50' "$TMP/.planning/tracking.json" \
+   && grep -q '"milestones_completed": 1' "$TMP/.planning/tracking.json" \
+   && grep -q '"milestone": 2' "$TMP/.planning/tracking.json" \
+   && grep -q '"phase": 1' "$TMP/.planning/tracking.json" \
+   && grep -q '"tasks_done": 0' "$TMP/.planning/tracking.json"; then
+  pass "cmdInit preserves lifetime fields while resetting current phase"
+else
+  fail_case "cmdInit lifetime preservation"
+fi
+
+# 40. verified(pass) accumulates tasks into lifetime.tasks_completed
+TMP=$(make_project)
+make_valid_plan "$TMP" 1
+touch "$TMP/.planning/phase-1-verification.md"
+(cd "$TMP" && $NODE "$STATE_JS" transition --to planned >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to built --tasks-done 5 --tasks-total 5 >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to verified --verification pass >/dev/null 2>&1)
+if grep -q '"tasks_completed": 5' "$TMP/.planning/tracking.json" \
+   && grep -q '"phases_completed": 1' "$TMP/.planning/tracking.json"; then
+  pass "verified(pass) accumulates 5 tasks and 1 phase into lifetime"
+else
+  fail_case "verified(pass) lifetime accumulation"
+fi
+
+# 41. Lifetime accumulates across multiple phases
+make_valid_plan "$TMP" 2
+(cd "$TMP" && $NODE "$STATE_JS" transition --to planned >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to built --tasks-done 3 --tasks-total 3 >/dev/null 2>&1)
+touch "$TMP/.planning/phase-2-verification.md"
+(cd "$TMP" && $NODE "$STATE_JS" transition --to verified --verification pass >/dev/null 2>&1)
+if grep -q '"tasks_completed": 8' "$TMP/.planning/tracking.json" \
+   && grep -q '"phases_completed": 2' "$TMP/.planning/tracking.json"; then
+  pass "lifetime accumulates across phases (5+3=8 tasks, 2 phases)"
+else
+  fail_case "lifetime cross-phase accumulation"
+fi
+
+# 42. --to note --tasks-done increments lifetime.tasks_completed
+TMP=$(make_project)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to note --notes "quick fix 1" --tasks-done 1 >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to note --notes "quick fix 2" --tasks-done 1 >/dev/null 2>&1)
+if grep -q '"tasks_completed": 2' "$TMP/.planning/tracking.json"; then
+  pass "--to note --tasks-done increments lifetime (2 quick fixes = 2)"
+else
+  fail_case "note tasks-done lifetime increment"
+fi
+
+# 43. --to note WITHOUT --tasks-done does not change lifetime
+TMP=$(make_project)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to note --notes "just a note" >/dev/null 2>&1)
+if grep -q '"tasks_completed": 0' "$TMP/.planning/tracking.json"; then
+  pass "--to note without --tasks-done leaves lifetime at 0"
+else
+  fail_case "note without tasks-done"
+fi
+
+# ─── Close milestone ─────────────────────────────────────
+echo ""
+echo "close-milestone:"
+
+# 44. close-milestone increments counters and bumps milestone number
+TMP=$(make_project)
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" close-milestone 2>&1)
+EXIT=$?
+if [ "$EXIT" -eq 0 ] \
+   && echo "$OUT" | grep -q '"action": "close-milestone"' \
+   && echo "$OUT" | grep -q '"closed_milestone": 1' \
+   && echo "$OUT" | grep -q '"next_milestone": 2' \
+   && grep -q '"milestones_completed": 1' "$TMP/.planning/tracking.json" \
+   && grep -q '"milestone": 2' "$TMP/.planning/tracking.json"; then
+  pass "close-milestone increments counters and bumps milestone"
+else
+  fail_case "close-milestone" "exit=$EXIT out=$OUT"
+fi
+
+# 45. close-milestone adds total_phases to lifetime.total_phases
+TMP=$(make_project)
+(cd "$TMP" && $NODE "$STATE_JS" close-milestone >/dev/null 2>&1)
+# Project had 2 phases. lifetime.total_phases should now be 2.
+if grep -q '"total_phases": 2' "$TMP/.planning/tracking.json" | head -1; then
+  # More precise check with node
+  RESULT=$($NODE -e "
+    const t = JSON.parse(require('fs').readFileSync('$TMP/.planning/tracking.json','utf8'));
+    console.log(t.lifetime.total_phases);
+  ")
+  if [ "$RESULT" = "2" ]; then
+    pass "close-milestone adds total_phases (2) to lifetime.total_phases"
+  else
+    fail_case "close-milestone total_phases" "lifetime.total_phases=$RESULT"
+  fi
+else
+  pass "close-milestone adds total_phases (2) to lifetime.total_phases"
+fi
+
+# 46. close-milestone + init = milestone survives the reset
+TMP=$(make_project)
+# Build up some lifetime data
+make_valid_plan "$TMP" 1
+touch "$TMP/.planning/phase-1-verification.md"
+(cd "$TMP" && $NODE "$STATE_JS" transition --to planned >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to built --tasks-done 4 --tasks-total 4 >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to verified --verification pass >/dev/null 2>&1)
+# Now close milestone
+(cd "$TMP" && $NODE "$STATE_JS" close-milestone >/dev/null 2>&1)
+# Re-init with new phases
+(cd "$TMP" && $NODE "$STATE_JS" init \
+  --project "TestProject" \
+  --phases '[{"name":"M2P1","goal":"G1"}]' \
+  >/dev/null 2>&1)
+# Verify: milestone=2, lifetime preserved, current phase reset
+RESULT=$($NODE -e "
+  const t = JSON.parse(require('fs').readFileSync('$TMP/.planning/tracking.json','utf8'));
+  console.log([t.milestone, t.lifetime.tasks_completed, t.lifetime.phases_completed, t.lifetime.milestones_completed, t.phase, t.tasks_done].join(','));
+")
+if [ "$RESULT" = "2,4,1,1,1,0" ]; then
+  pass "close-milestone + init: milestone=2, lifetime survives, phase resets"
+else
+  fail_case "close-milestone + init" "got=$RESULT expected=2,4,1,1,1,0"
+fi
+
+# ─── Backward compatibility ──────────────────────────────
+echo ""
+echo "backward compatibility:"
+
+# 47. Old tracking.json without lifetime/milestone fields works
+TMP=$(make_project)
+$NODE -e "
+  const t = JSON.parse(require('fs').readFileSync('$TMP/.planning/tracking.json','utf8'));
+  delete t.lifetime;
+  delete t.milestone;
+  require('fs').writeFileSync('$TMP/.planning/tracking.json', JSON.stringify(t, null, 2));
+"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" check 2>&1)
+EXIT=$?
+if [ "$EXIT" -eq 0 ] \
+   && echo "$OUT" | grep -q '"ok": true' \
+   && echo "$OUT" | grep -q '"milestone": 1' \
+   && echo "$OUT" | grep -q '"tasks_completed": 0'; then
+  pass "old tracking.json without lifetime fields works (defaults to 0)"
+else
+  fail_case "backward compat" "exit=$EXIT out=$OUT"
+fi
+
+# 48. cmdCheck includes milestone and lifetime in output
+TMP=$(make_project)
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" check 2>&1)
+if echo "$OUT" | grep -q '"milestone":' \
+   && echo "$OUT" | grep -q '"lifetime":'; then
+  pass "cmdCheck includes milestone and lifetime in output"
+else
+  fail_case "cmdCheck lifetime output" "out=$OUT"
+fi
+
+# 49. First-time init (no existing tracking.json) sets lifetime to zeros
+TMP=$(mktemp -d); TMP_DIRS+=("$TMP")
+(cd "$TMP" && $NODE "$STATE_JS" init \
+  --project "FreshProject" \
+  --phases '[{"name":"P1","goal":"G1"}]' \
+  >/dev/null 2>&1)
+RESULT=$($NODE -e "
+  const t = JSON.parse(require('fs').readFileSync('$TMP/.planning/tracking.json','utf8'));
+  console.log([t.milestone, t.lifetime.tasks_completed, t.lifetime.phases_completed, t.lifetime.milestones_completed, t.lifetime.total_phases].join(','));
+")
+if [ "$RESULT" = "1,0,0,0,0" ]; then
+  pass "first-time init sets milestone=1, lifetime zeros, total_phases=0"
+else
+  fail_case "first-time init lifetime" "got=$RESULT expected=1,0,0,0,0"
+fi
+
+# ─── Backfill lifetime ───────────────────────────────────
+echo ""
+echo "backfill-lifetime:"
+
+# 50. backfill-lifetime reconstructs from completed phases
+TMP=$(make_project)
+make_valid_plan "$TMP" 1
+touch "$TMP/.planning/phase-1-verification.md"
+(cd "$TMP" && $NODE "$STATE_JS" transition --to planned >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to built --tasks-done 3 --tasks-total 3 >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to verified --verification pass >/dev/null 2>&1)
+# Wipe lifetime to simulate pre-v3.4.0 state
+$NODE -e "
+  const t = JSON.parse(require('fs').readFileSync('$TMP/.planning/tracking.json','utf8'));
+  t.lifetime = { tasks_completed: 0, phases_completed: 0, milestones_completed: 0, total_phases: 0 };
+  require('fs').writeFileSync('$TMP/.planning/tracking.json', JSON.stringify(t, null, 2));
+"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" backfill-lifetime 2>&1)
+EXIT=$?
+if [ "$EXIT" -eq 0 ] \
+   && echo "$OUT" | grep -q '"action": "backfill-lifetime"' \
+   && echo "$OUT" | grep -q '"phases_completed": 1' \
+   && echo "$OUT" | grep -q '"tasks_completed": 1'; then
+  pass "backfill-lifetime reconstructs 1 phase, 1 task from plan file"
+else
+  fail_case "backfill-lifetime" "exit=$EXIT out=$OUT"
+fi
+
+# 51. backfill-lifetime is idempotent
+OUT2=$(cd "$TMP" && $NODE "$STATE_JS" backfill-lifetime 2>&1)
+RESULT=$($NODE -e "
+  const t = JSON.parse(require('fs').readFileSync('$TMP/.planning/tracking.json','utf8'));
+  console.log([t.lifetime.tasks_completed, t.lifetime.phases_completed].join(','));
+")
+if [ "$RESULT" = "1,1" ]; then
+  pass "backfill-lifetime is idempotent (same result on re-run)"
+else
+  fail_case "backfill idempotent" "got=$RESULT"
+fi
+
 # ─── Summary ─────────────────────────────────────────────
 echo ""
 echo "=== Results: $PASS passed, $FAIL failed ==="