gsd-pi 2.47.0-dev.04be8c9 → 2.47.0-dev.f2e721d

package/src/resources/extensions/gsd/tests/forensics-journal.test.ts

@@ -0,0 +1,162 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+describe("forensics journal & activity log awareness", () => {
+  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+  const promptSrc = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
+
+  it("scanJournalForForensics reads journal files directly (no full queryJournal load)", () => {
+    // Must NOT use queryJournal which loads ALL entries into memory
+    assert.ok(
+      !forensicsSrc.includes('queryJournal('),
+      "forensics.ts must NOT call queryJournal() which loads all entries at once",
+    );
+    // Must have its own journal scanning with file-level limits
+    assert.ok(
+      forensicsSrc.includes("scanJournalForForensics"),
+      "forensics.ts must have scanJournalForForensics function",
+    );
+  });
+
+  it("journal scanning limits files parsed to avoid memory bloat", () => {
+    assert.ok(
+      forensicsSrc.includes("MAX_JOURNAL_RECENT_FILES"),
+      "must have MAX_JOURNAL_RECENT_FILES constant to limit parsed files",
+    );
+    assert.ok(
+      forensicsSrc.includes("MAX_JOURNAL_RECENT_EVENTS"),
+      "must have MAX_JOURNAL_RECENT_EVENTS constant to limit events extracted",
+    );
+  });
+
+  it("older journal files are line-counted without full JSON parse", () => {
+    assert.ok(
+      forensicsSrc.includes("olderEntryCount") || forensicsSrc.includes("olderFiles"),
+      "must handle older files separately from recent files",
+    );
+  });
+
+  it("ForensicReport includes journalSummary field", () => {
+    assert.ok(
+      forensicsSrc.includes("journalSummary"),
+      "ForensicReport must include journalSummary field",
+    );
+  });
+
+  it("ForensicReport includes activityLogMeta field", () => {
+    assert.ok(
+      forensicsSrc.includes("activityLogMeta"),
+      "ForensicReport must include activityLogMeta field",
+    );
+  });
+
+  it("buildForensicReport calls scanJournalForForensics", () => {
+    assert.ok(
+      forensicsSrc.includes("scanJournalForForensics"),
+      "buildForensicReport must call scanJournalForForensics",
+    );
+  });
+
+  it("buildForensicReport calls gatherActivityLogMeta", () => {
+    assert.ok(
+      forensicsSrc.includes("gatherActivityLogMeta"),
+      "buildForensicReport must call gatherActivityLogMeta",
+    );
+  });
+
+  it("forensics detects journal-based anomalies", () => {
+    assert.ok(
+      forensicsSrc.includes("detectJournalAnomalies"),
+      "forensics.ts must have detectJournalAnomalies function",
+    );
+    // Check for specific journal anomaly types
+    assert.ok(forensicsSrc.includes('"journal-stuck"'), "must detect journal-stuck anomalies");
+    assert.ok(forensicsSrc.includes('"journal-guard-block"'), "must detect journal-guard-block anomalies");
+    assert.ok(forensicsSrc.includes('"journal-rapid-iterations"'), "must detect journal-rapid-iterations anomalies");
+    assert.ok(forensicsSrc.includes('"journal-worktree-failure"'), "must detect journal-worktree-failure anomalies");
+  });
+
+  it("formatReportForPrompt includes journal summary section", () => {
+    assert.ok(
+      forensicsSrc.includes("Journal Summary"),
+      "prompt formatter must include a Journal Summary section",
+    );
+  });
+
+  it("formatReportForPrompt includes activity log overview section", () => {
+    assert.ok(
+      forensicsSrc.includes("Activity Log Overview"),
+      "prompt formatter must include an Activity Log Overview section",
+    );
+  });
+
+  it("activity log scanning uses tail-read with byte cap (not full file load)", () => {
+    // scanActivityLogs uses nativeParseJsonlTail + MAX_JSONL_BYTES for efficient reading
+    assert.ok(
+      forensicsSrc.includes("nativeParseJsonlTail"),
+      "activity log scanning must use nativeParseJsonlTail for tail-reading",
+    );
+    assert.ok(
+      forensicsSrc.includes("MAX_JSONL_BYTES"),
+      "activity log scanning must respect MAX_JSONL_BYTES cap",
+    );
+    // Only reads last 5 files
+    assert.ok(
+      forensicsSrc.includes("slice(-5)"),
+      "activity log scanning must limit to last 5 files",
+    );
+  });
+
+  it("activity log entries are distilled through extractTrace, not sent raw", () => {
+    assert.ok(
+      forensicsSrc.includes("extractTrace("),
+      "activity log entries must be distilled through extractTrace before reporting",
+    );
+  });
+
+  it("prompt output is hard-capped at 30KB", () => {
+    assert.ok(
+      forensicsSrc.includes("MAX_BYTES") && forensicsSrc.includes("30 * 1024"),
+      "formatReportForPrompt must have a 30KB hard cap",
+    );
+    assert.ok(
+      forensicsSrc.includes("truncated at 30KB"),
+      "prompt must show truncation message when capped",
+    );
+  });
+
+  it("forensics prompt documents journal format", () => {
+    assert.ok(
+      promptSrc.includes("### Journal Format"),
+      "forensics.md must document the journal format",
+    );
+    assert.ok(
+      promptSrc.includes("flowId"),
+      "forensics.md must reference flowId concept",
+    );
+    assert.ok(
+      promptSrc.includes("causedBy"),
+      "forensics.md must reference causedBy for causal chains",
+    );
+  });
+
+  it("forensics prompt includes journal directory in runtime path reference", () => {
+    assert.ok(
+      promptSrc.includes("journal/"),
+      "forensics.md runtime path reference must include journal/",
+    );
+  });
+
+  it("investigation protocol references journal data", () => {
+    assert.ok(
+      promptSrc.includes("journal timeline") || promptSrc.includes("journal events"),
+      "investigation protocol must reference journal data for tracing",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/preflight-context-draft-filter.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Regression test for #2473: Pre-flight CONTEXT-DRAFT warning should skip
+ * completed and parked milestones.
+ *
+ * The pre-flight loop in auto-start.ts warns about CONTEXT-DRAFT.md files
+ * so the user knows which milestones will pause for discussion. But completed
+ * milestones with leftover CONTEXT-DRAFT.md files are not actionable — the
+ * warning is noise.
+ *
+ * This test exercises the filtering logic directly: given a set of milestones
+ * with CONTEXT-DRAFT files, only active/pending ones should produce warnings.
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  isDbAvailable,
+  insertMilestone,
+  getMilestone,
+} from "../gsd-db.ts";
+import { resolveMilestoneFile } from "../paths.ts";
+
+describe("pre-flight CONTEXT-DRAFT filter (#2473)", () => {
+  let tmpBase: string;
+  let gsd: string;
+
+  beforeEach(() => {
+    tmpBase = mkdtempSync(join(tmpdir(), "gsd-preflight-draft-"));
+    gsd = join(tmpBase, ".gsd");
+
+    // Create milestone directories with CONTEXT-DRAFT files
+    for (const id of ["M001", "M002", "M003"]) {
+      const msDir = join(gsd, "milestones", id);
+      mkdirSync(msDir, { recursive: true });
+      writeFileSync(join(msDir, `${id}-CONTEXT-DRAFT.md`), `# ${id}: Draft\n`);
+    }
+
+    // Open DB and insert milestones with different statuses
+    const dbPath = join(gsd, "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Complete milestone", status: "complete" });
+    insertMilestone({ id: "M002", title: "Active milestone", status: "active" });
+    insertMilestone({ id: "M003", title: "Parked milestone", status: "parked" });
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  test("completed milestone is skipped — no warning emitted", () => {
+    assert.ok(isDbAvailable(), "DB should be available");
+    const ms = getMilestone("M001");
+    assert.equal(ms?.status, "complete");
+  });
+
+  test("parked milestone is skipped — no warning emitted", () => {
+    const ms = getMilestone("M003");
+    assert.equal(ms?.status, "parked");
+  });
+
+  test("active milestone with CONTEXT-DRAFT produces warning", () => {
+    const ms = getMilestone("M002");
+    assert.equal(ms?.status, "active");
+
+    const draft = resolveMilestoneFile(tmpBase, "M002", "CONTEXT-DRAFT");
+    assert.ok(draft, "CONTEXT-DRAFT file should be found for active milestone");
+  });
+
+  test("full pre-flight filter produces warnings only for active milestones", () => {
+    const milestoneIds = ["M001", "M002", "M003"];
+    const issues: string[] = [];
+
+    for (const id of milestoneIds) {
+      // Replicate the fixed pre-flight logic from auto-start.ts
+      if (isDbAvailable()) {
+        const ms = getMilestone(id);
+        if (ms?.status === "complete" || ms?.status === "parked") continue;
+      }
+      const draft = resolveMilestoneFile(tmpBase, id, "CONTEXT-DRAFT");
+      if (draft) {
+        issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);
+      }
+    }
+
+    assert.equal(issues.length, 1, "only one warning should be emitted");
+    assert.match(issues[0], /M002/, "warning should be for the active milestone only");
+  });
+
+  test("when DB is unavailable, all milestones with CONTEXT-DRAFT produce warnings (safe fallback)", () => {
+    closeDatabase();
+    assert.ok(!isDbAvailable(), "DB should be unavailable after close");
+
+    const milestoneIds = ["M001", "M002", "M003"];
+    const issues: string[] = [];
+
+    for (const id of milestoneIds) {
+      if (isDbAvailable()) {
+        const ms = getMilestone(id);
+        if (ms?.status === "complete" || ms?.status === "parked") continue;
+      }
+      const draft = resolveMilestoneFile(tmpBase, id, "CONTEXT-DRAFT");
+      if (draft) {
+        issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);
+      }
+    }
+
+    assert.equal(issues.length, 3, "all milestones should warn when DB is unavailable");
+  });
+});

package/src/resources/extensions/gsd/tests/stale-milestone-id-reservation.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Regression test for #2488: Stale milestone ID reservations inflate next ID
+ * after cancelled /gsd sessions.
+ *
+ * The module-level `reservedMilestoneIds` Set persists across /gsd invocations
+ * within the same Node process. Without clearReservedMilestoneIds() at session
+ * start, each cancelled session permanently bumps the counter by 1.
+ */
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  nextMilestoneId,
+  reserveMilestoneId,
+  getReservedMilestoneIds,
+  clearReservedMilestoneIds,
+} from "../milestone-ids.ts";
+
+describe("stale milestone ID reservation cleanup (#2488)", () => {
+  beforeEach(() => {
+    clearReservedMilestoneIds();
+  });
+
+  test("without cleanup, cancelled sessions inflate the next ID", () => {
+    const diskIds = ["M001", "M002", "M003"];
+
+    // Session 1: user starts /gsd, ID is previewed and reserved, then cancelled
+    const allIds1 = [...new Set([...diskIds, ...getReservedMilestoneIds()])];
+    const preview1 = nextMilestoneId(allIds1);
+    reserveMilestoneId(preview1);
+    assert.equal(preview1, "M004");
+
+    // Session 2: user starts /gsd again — stale reservation still in Set
+    // WITHOUT clearing, the next ID skips M004 (reserved) and goes to M005
+    const allIds2 = [...new Set([...diskIds, ...getReservedMilestoneIds()])];
+    const preview2 = nextMilestoneId(allIds2);
+    assert.equal(preview2, "M005", "without cleanup, ID inflates to M005");
+  });
+
+  test("with cleanup at session start, next ID is correct", () => {
+    const diskIds = ["M001", "M002", "M003"];
+
+    // Session 1: user starts /gsd, ID is previewed and reserved, then cancelled
+    const allIds1 = [...new Set([...diskIds, ...getReservedMilestoneIds()])];
+    const preview1 = nextMilestoneId(allIds1);
+    reserveMilestoneId(preview1);
+    assert.equal(preview1, "M004");
+
+    // Session 2: clear stale reservations first (the fix)
+    clearReservedMilestoneIds();
+
+    // Now the next ID correctly returns M004 again
+    const allIds2 = [...new Set([...diskIds, ...getReservedMilestoneIds()])];
+    const preview2 = nextMilestoneId(allIds2);
+    assert.equal(preview2, "M004", "after cleanup, ID is correctly M004");
+  });
+
+  test("multiple cancelled sessions compound the inflation without cleanup", () => {
+    const diskIds = ["M001", "M002", "M003"];
+
+    // 3 cancelled sessions without cleanup
+    for (let i = 0; i < 3; i++) {
+      const allIds = [...new Set([...diskIds, ...getReservedMilestoneIds()])];
+      const preview = nextMilestoneId(allIds);
+      reserveMilestoneId(preview);
+    }
+
+    // Without cleanup, we're now at M007 instead of M004
+    const allIds = [...new Set([...diskIds, ...getReservedMilestoneIds()])];
+    const next = nextMilestoneId(allIds);
+    assert.equal(next, "M007", "3 cancelled sessions inflate ID by 3");
+
+    // With cleanup, we're back to M004
+    clearReservedMilestoneIds();
+    const allIdsClean = [...new Set([...diskIds, ...getReservedMilestoneIds()])];
+    const nextClean = nextMilestoneId(allIdsClean);
+    assert.equal(nextClean, "M004", "cleanup restores correct next ID");
+  });
+});