gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

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

@@ -1,162 +0,0 @@
-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/gitignore-bg-shell.test.ts

@@ -1,38 +0,0 @@
-/**
- * Regression test — .bg-shell/ added to BASELINE_PATTERNS in gitignore.ts
- *
- * The bg-shell background process directory was not included in the
- * baseline gitignore patterns, causing it to appear as untracked in
- * git status and potentially be committed.
- *
- * Structural verification test — reads source to confirm .bg-shell/
- * is in BASELINE_PATTERNS.
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'gitignore.ts'), 'utf-8');
-
-describe('.bg-shell/ in BASELINE_PATTERNS', () => {
-  test('BASELINE_PATTERNS array is defined', () => {
-    assert.match(source, /const BASELINE_PATTERNS\s*=/,
-      'BASELINE_PATTERNS should be defined');
-  });
-
-  test('.bg-shell/ is included in BASELINE_PATTERNS', () => {
-    // Extract the BASELINE_PATTERNS array content
-    const patternsStart = source.indexOf('BASELINE_PATTERNS');
-    const arrayStart = source.indexOf('[', patternsStart);
-    const arrayEnd = source.indexOf('] as const', arrayStart);
-    const patternsContent = source.slice(arrayStart, arrayEnd);
-    assert.match(patternsContent, /\.bg-shell\//,
-      '.bg-shell/ should be in BASELINE_PATTERNS');
-  });
-});

package/src/resources/extensions/gsd/tests/gsd-no-project-error.test.ts

@@ -1,73 +0,0 @@
-/**
- * GSDNoProjectError — tests for friendly home-directory error handling.
- *
- * Verifies that GSDNoProjectError is thrown for blocked directories and
- * that the dispatcher catches it with a user-friendly message.
- */
-
-import test 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 contextSrc = readFileSync(join(__dirname, "..", "commands", "context.ts"), "utf-8");
-const dispatcherSrc = readFileSync(join(__dirname, "..", "commands", "dispatcher.ts"), "utf-8");
-
-// ─── GSDNoProjectError class ──────────────────────────────────────────────
-
-test("GSDNoProjectError class is exported from context.ts", () => {
-  assert.ok(
-    contextSrc.includes("export class GSDNoProjectError extends Error"),
-    "GSDNoProjectError should be an exported Error subclass",
-  );
-});
-
-test("GSDNoProjectError sets name property", () => {
-  assert.ok(
-    contextSrc.includes('this.name = "GSDNoProjectError"'),
-    "GSDNoProjectError should set its name for instanceof checks",
-  );
-});
-
-// ─── projectRoot blocked directory handling ───────────────────────────────
-
-test("projectRoot uses validateDirectory and checks for blocked severity", () => {
-  assert.ok(
-    contextSrc.includes("validateDirectory(pathToCheck)"),
-    "projectRoot should call validateDirectory",
-  );
-  assert.ok(
-    contextSrc.includes('result.severity === "blocked"'),
-    "projectRoot should check for blocked severity",
-  );
-});
-
-test("projectRoot throws GSDNoProjectError on blocked directory", () => {
-  assert.ok(
-    contextSrc.includes("throw new GSDNoProjectError"),
-    "projectRoot should throw GSDNoProjectError when directory is blocked",
-  );
-});
-
-// ─── Dispatcher catch ─────────────────────────────────────────────────────
-
-test("dispatcher catches GSDNoProjectError with user-friendly message", () => {
-  assert.ok(
-    dispatcherSrc.includes("err instanceof GSDNoProjectError"),
-    "dispatcher should catch GSDNoProjectError specifically",
-  );
-  assert.ok(
-    dispatcherSrc.includes("cd"),
-    "error message should suggest cd-ing into a project directory",
-  );
-});
-
-test("dispatcher re-throws non-GSDNoProjectError exceptions", () => {
-  assert.ok(
-    dispatcherSrc.includes("throw err"),
-    "dispatcher should re-throw unexpected errors",
-  );
-});

package/src/resources/extensions/gsd/tests/idle-watchdog-stall-override.test.ts

@@ -1,125 +0,0 @@
-/**
- * Regression tests for #2527: idle watchdog stalled-tool detection.
- *
- * Bug 1: When a tool is stalled longer than idle_timeout, the watchdog
- * notifies but falls through to detectWorkingTreeActivity(), which
- * resets lastProgressAt if files were modified earlier. Recovery is
- * never called — the session burns tokens indefinitely.
- *
- * Bug 2: After async recoverTimedOutUnit(), pauseAuto/stopAuto may set
- * s.currentUnit = null, but the next line accesses .startedAt — crash.
- *
- * These tests verify the auto-timers.ts source contains the structural
- * fixes: the stalledToolDetected flag, clearInFlightTools() call, the
- * filesystem-check guard, and the null guard after recovery.
- */
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-
-const TIMERS_SRC = readFileSync(
-  join(import.meta.dirname, "..", "auto-timers.ts"),
-  "utf-8",
-);
-
-// ═══ Bug 1: stalledToolDetected flag prevents filesystem-activity override ═══
-
-describe("#2527 Bug 1: stalled tool should not be overridden by filesystem activity", () => {
-  test("auto-timers.ts imports clearInFlightTools", () => {
-    assert.ok(
-      TIMERS_SRC.includes("clearInFlightTools"),
-      "clearInFlightTools must be imported from auto-tool-tracking",
-    );
-  });
-
-  test("auto-timers.ts declares stalledToolDetected flag", () => {
-    assert.ok(
-      TIMERS_SRC.includes("stalledToolDetected"),
-      "stalledToolDetected flag must exist in idle watchdog",
-    );
-  });
-
-  test("stalled tool sets flag to true", () => {
-    // The flag must be set before the filesystem check
-    const flagSet = TIMERS_SRC.indexOf("stalledToolDetected = true");
-    assert.ok(flagSet > -1, "stalledToolDetected must be set to true when tool is stalled");
-
-    const notify = TIMERS_SRC.indexOf("Stalled tool detected:");
-    assert.ok(flagSet < notify, "flag must be set before the stall notification");
-  });
-
-  test("stalled tool calls clearInFlightTools", () => {
-    // clearInFlightTools() must be called when tool is stalled, so subsequent
-    // watchdog ticks don't re-detect the same stale entries
-    const clearCall = TIMERS_SRC.indexOf("clearInFlightTools()");
-    assert.ok(clearCall > -1, "clearInFlightTools() must be called when tool is stalled");
-
-    const flagSet = TIMERS_SRC.indexOf("stalledToolDetected = true");
-    assert.ok(
-      Math.abs(clearCall - flagSet) < 200,
-      "clearInFlightTools() should be near stalledToolDetected = true",
-    );
-  });
-
-  test("filesystem-activity check is guarded by stalledToolDetected", () => {
-    // The detectWorkingTreeActivity check must be skipped when stalledToolDetected is true
-    assert.ok(
-      TIMERS_SRC.includes("!stalledToolDetected && detectWorkingTreeActivity"),
-      "detectWorkingTreeActivity must be guarded by !stalledToolDetected",
-    );
-  });
-
-  test("control flow: stalled tool → skip filesystem check → reach recovery", () => {
-    // Verify the structural ordering: flag declaration → stall block → guarded fs check → recovery
-    const flagDecl = TIMERS_SRC.indexOf("let stalledToolDetected = false");
-    const stallBlock = TIMERS_SRC.indexOf("stalledToolDetected = true");
-    const fsGuard = TIMERS_SRC.indexOf("!stalledToolDetected && detectWorkingTreeActivity");
-    const recovery = TIMERS_SRC.indexOf("recoverTimedOutUnit(ctx, pi, unitType, unitId, \"idle\"");
-
-    assert.ok(flagDecl > -1, "flag declaration must exist");
-    assert.ok(flagDecl < stallBlock, "flag declared before stall block");
-    assert.ok(stallBlock < fsGuard, "stall block before filesystem guard");
-    assert.ok(fsGuard < recovery, "filesystem guard before recovery call");
-  });
-});
-
-// ═══ Bug 2: null guard after async recoverTimedOutUnit ═══════════════════════
-
-describe("#2527 Bug 2: null guard after async recovery prevents crash", () => {
-  test("idle watchdog has null guard after recoverTimedOutUnit", () => {
-    // Find the idle recovery call
-    const idleRecovery = TIMERS_SRC.indexOf(
-      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
-    );
-    assert.ok(idleRecovery > -1, "idle recovery call must exist");
-
-    // The null guard must appear between the recovery call and the next
-    // writeUnitRuntimeRecord that accesses s.currentUnit.startedAt
-    const afterRecovery = TIMERS_SRC.slice(idleRecovery, idleRecovery + 400);
-    assert.ok(
-      afterRecovery.includes("if (!s.currentUnit) return"),
-      "null guard for s.currentUnit must exist after idle recoverTimedOutUnit",
-    );
-  });
-
-  test("null guard is between recovery and writeUnitRuntimeRecord", () => {
-    const idleRecovery = TIMERS_SRC.indexOf(
-      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
-    );
-    const afterRecovery = TIMERS_SRC.slice(idleRecovery);
-
-    const recoveredReturn = afterRecovery.indexOf('if (recovery === "recovered") return');
-    const nullGuard = afterRecovery.indexOf("if (!s.currentUnit) return");
-    const writeRecord = afterRecovery.indexOf("writeUnitRuntimeRecord(s.basePath");
-
-    assert.ok(recoveredReturn > -1, "recovered return must exist");
-    assert.ok(nullGuard > -1, "null guard must exist");
-    assert.ok(writeRecord > -1, "writeUnitRuntimeRecord must exist after recovery");
-    assert.ok(
-      recoveredReturn < nullGuard && nullGuard < writeRecord,
-      "order must be: recovered-return → null-guard → writeUnitRuntimeRecord",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/import-done-milestones.test.ts

@@ -1,42 +0,0 @@
-/**
- * Regression test for #3699 — import milestones with all-done slices as complete
- *
- * During DB migration, milestones whose roadmap slices are all marked done
- * should be imported with status "complete" instead of "active".
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const importerSrc = readFileSync(
-  join(__dirname, '..', 'md-importer.ts'),
-  'utf-8',
-);
-
-describe('import done milestones as complete (#3699)', () => {
-  test('all-slices-done check sets milestoneStatus to complete', () => {
-    // The importer should check if all roadmap slices are done
-    assert.match(importerSrc, /roadmap\.slices\.every\(s\s*=>\s*s\.done\)/,
-      'should check roadmap.slices.every(s => s.done)');
-  });
-
-  test('milestoneStatus is set to complete when all slices done', () => {
-    // Find the all-done guard and verify it sets 'complete'
-    const everyIdx = importerSrc.indexOf('roadmap.slices.every(s => s.done)');
-    assert.ok(everyIdx > -1, 'all-slices-done check should exist');
-    const afterCheck = importerSrc.slice(everyIdx, everyIdx + 200);
-    assert.match(afterCheck, /milestoneStatus\s*=\s*'complete'/,
-      'should set milestoneStatus to complete when all slices are done');
-  });
-
-  test('roadmap.slices.length > 0 guard prevents false positives', () => {
-    assert.match(importerSrc, /roadmap\.slices\.length\s*>\s*0/,
-      'should guard against empty slices array');
-  });
-});