@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/mcp-filter.test.ts

@@ -1,6 +1,7 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import fs, { mkdtempSync, writeFileSync, mkdirSync, utimesSync } from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -107,6 +108,78 @@ describe("discoverMcpServerNames", () => {
     );
     assert.equal(discoverBrowserMcpServerName(dir), "browser-uat");
   });
+
+  it("invalidates cached project MCP config when .mcp.json changes", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-cache-test-"));
+    const configPath = join(dir, ".mcp.json");
+    writeFileSync(configPath, JSON.stringify({ mcpServers: { "server-a": {} } }));
+    assert.deepEqual(discoverMcpServerNames(dir), ["server-a"]);
+
+    writeFileSync(configPath, JSON.stringify({ mcpServers: { "server-b": {} } }));
+    const later = new Date(Date.now() + 5_000);
+    utimesSync(configPath, later, later);
+
+    assert.deepEqual(discoverMcpServerNames(dir), ["server-b"]);
+  });
+
+  it("reuses parsed project MCP config across discovery helpers", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-cache-test-"));
+    const claudeDir = join(dir, ".claude");
+    const mcpJsonPath = join(dir, ".mcp.json");
+    const settingsPath = join(claudeDir, "settings.json");
+    const localSettingsPath = join(claudeDir, "settings.local.json");
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(
+      mcpJsonPath,
+      JSON.stringify({
+        mcpServers: {
+          "custom-workflow": {
+            command: "node",
+            args: ["custom-cli.js"],
+            env: { GSD_WORKFLOW_PROJECT_ROOT: dir },
+          },
+        },
+      }),
+    );
+    writeFileSync(
+      settingsPath,
+      JSON.stringify({ mcpServers: { "browser-uat": { command: "gsd-browser", args: ["mcp"] } } }),
+    );
+    writeFileSync(
+      localSettingsPath,
+      JSON.stringify({ mcpServers: { "local-server": { command: "npx", args: ["local"] } } }),
+    );
+
+    const trackedPaths = new Set([mcpJsonPath, settingsPath, localSettingsPath]);
+    const readCounts = new Map<string, number>();
+    const originalReadFileSync = fs.readFileSync;
+    fs.readFileSync = ((...args: Parameters<typeof fs.readFileSync>) => {
+      const path = args[0];
+      if (typeof path === "string" && trackedPaths.has(path)) {
+        readCounts.set(path, (readCounts.get(path) ?? 0) + 1);
+      }
+      return originalReadFileSync(...args);
+    }) as typeof fs.readFileSync;
+    syncBuiltinESMExports();
+
+    try {
+      const mcpFilter = await import(`../mcp-filter.ts?cache-test=${Date.now()}`);
+      const discovered = mcpFilter.discoverMcpServerNames(dir);
+      const workflowName = mcpFilter.discoverWorkflowMcpServerName(dir);
+      const browserName = mcpFilter.discoverBrowserMcpServerName(dir);
+
+      assert.deepEqual(discovered.sort(), ["browser-uat", "custom-workflow", "local-server"]);
+      assert.equal(workflowName, "custom-workflow");
+      assert.equal(browserName, "browser-uat");
+      assert.deepEqual(
+        [mcpJsonPath, settingsPath, localSettingsPath].map((path) => readCounts.get(path) ?? 0),
+        [1, 1, 1],
+      );
+    } finally {
+      fs.readFileSync = originalReadFileSync;
+      syncBuiltinESMExports();
+    }
+  });
 });
 
 // ─── computeMcpDisallowedTools ─────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/metrics-ledger-cap.test.ts

@@ -0,0 +1,239 @@
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  getLedger,
+  initMetrics,
+  METRICS_LEDGER_KEEP_UNITS,
+  resetMetrics,
+  snapshotUnitMetrics,
+  type MetricsLedger,
+  type UnitMetrics,
+} from "../metrics.js";
+
+function makeProjectDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-metrics-cap-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function metricsPath(base: string): string {
+  return join(base, ".gsd", "metrics.json");
+}
+
+function assistantCtx(): any {
+  return {
+    sessionManager: {
+      getEntries: () => [
+        {
+          type: "message",
+          id: "entry-0",
+          parentId: null,
+          timestamp: new Date().toISOString(),
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Done" }],
+            usage: {
+              input: 100,
+              output: 50,
+              cacheRead: 0,
+              cacheWrite: 0,
+              totalTokens: 150,
+              cost: 0.01,
+            },
+          },
+        },
+      ],
+    },
+  };
+}
+
+function makeUnit(index: number, id = `M001/S01/T${String(index).padStart(4, "0")}`): UnitMetrics {
+  const startedAt = 1_700_000_000_000 + index * 1000;
+  return {
+    type: "execute-task",
+    id,
+    model: "test-model",
+    startedAt,
+    finishedAt: startedAt + 500,
+    tokens: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, total: 15 },
+    cost: 0.001,
+    toolCalls: 1,
+    assistantMessages: 1,
+    userMessages: 1,
+    apiRequests: 1,
+  };
+}
+
+function writeLedger(base: string, units: UnitMetrics[]): void {
+  const ledger: MetricsLedger = {
+    version: 1,
+    projectStartedAt: 1_700_000_000_000,
+    units,
+  };
+  writeFileSync(metricsPath(base), JSON.stringify(ledger, null, 2) + "\n", "utf-8");
+}
+
+function readLedger(base: string): MetricsLedger {
+  return JSON.parse(readFileSync(metricsPath(base), "utf-8")) as MetricsLedger;
+}
+
+describe("metrics ledger steady-state cap", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    resetMetrics();
+  });
+
+  afterEach(() => {
+    resetMetrics();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("final cap preserves newest units by finishedAt when memory lags peer writes", () => {
+    // Scenario: memory loaded units 0..KEEP-1; a peer then advanced disk to
+    // units PEER_OFFSET..PEER_OFFSET+KEEP-1, adding PEER_OFFSET newer entries
+    // the worker has never seen.  The final keepNewestUnits call must rank by
+    // finishedAt, not by insertion order (disk-first), so old memory-only units
+    // do not crowd out newer on-disk peer units.
+    const KEEP = METRICS_LEDGER_KEEP_UNITS;
+    const PEER_OFFSET = 500;
+
+    // Load memory with units 0..KEEP-1.
+    const memUnits = Array.from({ length: KEEP }, (_, i) => makeUnit(i));
+    writeLedger(projectDir, memUnits);
+    initMetrics(projectDir);
+
+    // Peer advances disk to units PEER_OFFSET..PEER_OFFSET+KEEP-1.
+    const diskUnits = Array.from({ length: KEEP }, (_, i) => makeUnit(i + PEER_OFFSET));
+    writeLedger(projectDir, diskUnits);
+
+    // Trigger saveLedger.
+    const unit = snapshotUnitMetrics(
+      assistantCtx(),
+      "execute-task",
+      "M_STALE_MEM/S01/T01",
+      makeUnit(PEER_OFFSET + KEEP).startedAt,
+      "test-model",
+    );
+    assert.ok(unit, "snapshot must succeed");
+
+    const disk = readLedger(projectDir);
+    assert.equal(disk.units.length, KEEP, "disk must be capped at KEEP units");
+
+    // A disk unit that sits in the range evicted by insertion-order cap
+    // (positions 0..PEER_OFFSET-1 of the merged array) but must be kept
+    // by finishedAt-ordered cap because it is newer than memory-only units.
+    const diskUnitInEvictedRange = makeUnit(PEER_OFFSET + 1); // unit 501, newer than any memory-only unit
+    assert.ok(
+      disk.units.some((u) => u.id === diskUnitInEvictedRange.id),
+      `unit ${diskUnitInEvictedRange.id} (on-disk, newer than memory-only units) must not be displaced by stale memory tail`,
+    );
+
+    // The oldest surviving memory-only unit must be evicted.
+    const oldestMemOnlyUnit = makeUnit(1); // unit 1, older than all disk units (disk starts at 500)
+    assert.equal(
+      disk.units.some((u) => u.id === oldestMemOnlyUnit.id),
+      false,
+      `unit ${oldestMemOnlyUnit.id} (memory-only, older than all disk units) must be pruned`,
+    );
+  });
+
+  test("pre-merge cap preserves newest on-disk units even when disk order is stale", () => {
+    const KEEP = METRICS_LEDGER_KEEP_UNITS;
+
+    // Load memory with older local units.
+    const memUnits = Array.from(
+      { length: KEEP },
+      (_, i) => makeUnit(i, `M_MEM/S01/T${String(i).padStart(4, "0")}`),
+    );
+    writeLedger(projectDir, memUnits);
+    initMetrics(projectDir);
+
+    // Disk has more than KEEP entries, but its newest peer entries are at the
+    // head. A tail-slice pre-cap would discard these before the merge.
+    const newestPeerUnits = Array.from(
+      { length: 10 },
+      (_, i) => makeUnit(KEEP + i, `M_PEER/S01/T${String(i).padStart(4, "0")}`),
+    );
+    const olderPeerUnits = Array.from(
+      { length: KEEP },
+      (_, i) => makeUnit(i, `M_PEER_OLD/S01/T${String(i).padStart(4, "0")}`),
+    );
+    writeLedger(projectDir, [...newestPeerUnits, ...olderPeerUnits]);
+
+    const unit = snapshotUnitMetrics(
+      assistantCtx(),
+      "execute-task",
+      "M_STALE_DISK/S01/T01",
+      makeUnit(KEEP + newestPeerUnits.length).startedAt,
+      "test-model",
+    );
+    assert.ok(unit, "snapshot must succeed");
+
+    const disk = readLedger(projectDir);
+    assert.equal(disk.units.length, KEEP, "disk must be capped at KEEP units");
+    assert.ok(
+      disk.units.some((u) => u.id === newestPeerUnits[0]!.id),
+      "newer on-disk head unit must survive the pre-merge cap",
+    );
+  });
+
+  test("snapshot saves keep metrics.json and in-memory ledger bounded while preserving peer writes", () => {
+    const historicalUnits = Array.from(
+      { length: METRICS_LEDGER_KEEP_UNITS + 25 },
+      (_, index) => makeUnit(index),
+    );
+    writeLedger(projectDir, historicalUnits);
+
+    initMetrics(projectDir);
+
+    const peerUnit = makeUnit(historicalUnits.length, "M998/S01/T01");
+    writeLedger(projectDir, [...historicalUnits, peerUnit]);
+
+    const newStartedAt = peerUnit.startedAt + 1000;
+    const unit = snapshotUnitMetrics(
+      assistantCtx(),
+      "execute-task",
+      "M999/S01/T01",
+      newStartedAt,
+      "test-model",
+    );
+
+    assert.ok(unit, "snapshot should record the new unit");
+
+    const diskLedger = readLedger(projectDir);
+    assert.equal(diskLedger.units.length, METRICS_LEDGER_KEEP_UNITS);
+    assert.ok(
+      diskLedger.units.some((u) => u.id === peerUnit.id),
+      "peer unit written after init must survive the save merge",
+    );
+    assert.ok(
+      diskLedger.units.some((u) => u.id === "M999/S01/T01"),
+      "new unit must be persisted",
+    );
+    assert.equal(
+      diskLedger.units.some((u) => u.id === historicalUnits[0]!.id),
+      false,
+      "oldest history must be pruned from disk",
+    );
+
+    const memoryLedger = getLedger();
+    assert.equal(memoryLedger?.units.length, METRICS_LEDGER_KEEP_UNITS);
+    assert.equal(
+      memoryLedger?.units.some((u) => u.id === historicalUnits[0]!.id),
+      false,
+      "oldest history must be pruned from memory so the next save stays bounded",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/milestone-closeout.test.ts

@@ -154,7 +154,12 @@ test("isCompletedMilestoneTerminal accepts validation-pass with all slices close
 test("evaluateCompleteMilestoneDispatch repairs missing SUMMARY when DB is closed", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-dispatch-repair-summary-"));
   tmpDirs.push(base);
-  mkdirSync(join(base, ".gsd", "milestones", "M008"), { recursive: true });
+  const m008Dir = join(base, ".gsd", "milestones", "M008");
+  mkdirSync(m008Dir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone) so the layout sniffer treats it as a
+  // real legacy milestone rather than a metadata-only placeholder.
+  writeFileSync(join(m008Dir, "M008-CONTEXT.md"), "# M008\n");
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M008", title: "Live Text Search", status: "complete" });
   insertSlice({ id: "S01", milestoneId: "M008", title: "Slice", status: "complete" });
@@ -191,7 +196,7 @@ test("repairMissingMilestoneSummaryProjection succeeds when milestone dir does n
   const repair = await repairMissingMilestoneSummaryProjection(base, "M042");
   assert.equal(repair.ok, true, "repair should report success when handler creates the SUMMARY");
   assert.ok(
-    existsSync(join(base, ".gsd", "milestones", "M042", "M042-SUMMARY.md")),
+    existsSync(join(base, ".gsd", "phases", "42-m042", "42-SUMMARY.md")),
     "repair should write the SUMMARY artifact to the canonical projection path",
   );
 });

package/src/resources/extensions/gsd/tests/milestone-settlement.test.ts

@@ -55,7 +55,12 @@ function seedClosedMilestone(root: string, worktree: string): void {
     fullContent: "verdict: pass\n",
   });
 
-  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  const worktreeMilestoneDir = join(worktree, ".gsd", "milestones", "M001");
+  mkdirSync(worktreeMilestoneDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone) so the layout sniffer treats it as a
+  // real legacy milestone rather than a metadata-only placeholder.
+  writeFileSync(join(worktreeMilestoneDir, "M001-CONTEXT.md"), "# M001\n");
   const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", worktree);
   assert.ok(summaryPath, "complete-milestone summary path should resolve");
   mkdirSync(dirname(summaryPath), { recursive: true });