gsd-pi 2.78.0 → 2.78.1-dev.2d3fd6e71

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

@@ -0,0 +1,378 @@
+// GSD-2 + metrics-scope.test.ts: tests for scope-aware metrics variants (C6)
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  realpathSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+
+import {
+  initMetrics,
+  resetMetrics,
+  getLedger,
+  snapshotUnitMetrics,
+  initMetricsByScope,
+  getLedgerByScope,
+  resetMetricsByScope,
+  snapshotUnitMetricsByScope,
+  type MetricsLedger,
+  type UnitMetrics,
+} from "../metrics.js";
+import { createWorkspace, scopeMilestone } from "../workspace.js";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-metrics-scope-")));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function mockCtx(messages: any[] = []): any {
+  const entries = messages.map((msg, i) => ({
+    type: "message",
+    id: `entry-${i}`,
+    parentId: i > 0 ? `entry-${i - 1}` : null,
+    timestamp: new Date().toISOString(),
+    message: msg,
+  }));
+  return {
+    sessionManager: { getEntries: () => entries },
+    model: { id: "test-model" },
+  };
+}
+
+function assistantMsg(input = 1000, output = 500): any {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text: "done" }],
+    usage: {
+      input,
+      output,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: input + output,
+      cost: { total: 0.01 },
+    },
+  };
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("ByScope variant writes to the same path as legacy variant", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    resetMetrics();
+  });
+
+  afterEach(() => {
+    resetMetrics();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("metrics.json written by snapshotUnitMetrics matches path used by snapshotUnitMetricsByScope", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+
+    const ctx = mockCtx([assistantMsg()]);
+    const startedAt = Date.now() - 5000;
+
+    // Write via legacy path
+    initMetrics(projectDir);
+    snapshotUnitMetrics(ctx, "execute-task", "M001/S01/T01", startedAt, "test-model");
+    resetMetrics();
+
+    // Read via scope path
+    initMetricsByScope(scope);
+    const scopedLedger = getLedgerByScope(scope);
+    assert.ok(scopedLedger, "scoped ledger should load the same metrics.json");
+    assert.equal(scopedLedger!.units.length, 1, "should see the unit written by legacy path");
+    assert.equal(scopedLedger!.units[0].id, "M001/S01/T01");
+    resetMetricsByScope(scope);
+  });
+
+  test("snapshotUnitMetricsByScope writes to the same metrics.json as the legacy path", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+    const ctx = mockCtx([assistantMsg()]);
+    const startedAt = Date.now() - 5000;
+
+    // Write via scope path (no initMetrics called)
+    snapshotUnitMetricsByScope(scope, ctx, "execute-task", "M001/S01/T01", startedAt, "test-model");
+    resetMetricsByScope(scope);
+
+    // Read via legacy path
+    initMetrics(projectDir);
+    const legacyLedger = getLedger();
+    assert.ok(legacyLedger, "legacy path should read what the scope variant wrote");
+    assert.equal(legacyLedger!.units.length, 1);
+    assert.equal(legacyLedger!.units[0].id, "M001/S01/T01");
+    resetMetrics();
+  });
+});
+
+describe("ByScope variant is pinned to scope — cwd-drift does not move write target", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    resetMetrics();
+  });
+
+  afterEach(() => {
+    resetMetrics();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("write target is the scope's projectRoot regardless of process.cwd()", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+    const ctx = mockCtx([assistantMsg()]);
+    const startedAt = Date.now() - 3000;
+
+    // Record projectRoot before writing
+    const expectedMetricsPath = join(ws.projectRoot, ".gsd", "metrics.json");
+
+    snapshotUnitMetricsByScope(scope, ctx, "execute-task", "M001/S01/T01", startedAt, "test-model");
+
+    // Verify the file was written to the expected location
+    const raw = readFileSync(expectedMetricsPath, "utf-8");
+    const parsed: MetricsLedger = JSON.parse(raw);
+    assert.equal(parsed.units.length, 1);
+    assert.equal(parsed.units[0].id, "M001/S01/T01");
+
+    resetMetricsByScope(scope);
+  });
+
+  test("two scopes for different projectRoots write to separate metrics.json files", () => {
+    const projectDir2 = makeProjectDir();
+    try {
+      const ws1 = createWorkspace(projectDir);
+      const ws2 = createWorkspace(projectDir2);
+      const scope1 = scopeMilestone(ws1, "M001");
+      const scope2 = scopeMilestone(ws2, "M002");
+
+      const ctx = mockCtx([assistantMsg()]);
+      const startedAt = Date.now() - 3000;
+
+      snapshotUnitMetricsByScope(scope1, ctx, "execute-task", "M001/S01/T01", startedAt, "test-model");
+      snapshotUnitMetricsByScope(scope2, ctx, "execute-task", "M002/S01/T01", startedAt, "test-model");
+
+      const metrics1 = JSON.parse(
+        readFileSync(join(ws1.projectRoot, ".gsd", "metrics.json"), "utf-8"),
+      ) as MetricsLedger;
+      const metrics2 = JSON.parse(
+        readFileSync(join(ws2.projectRoot, ".gsd", "metrics.json"), "utf-8"),
+      ) as MetricsLedger;
+
+      assert.equal(metrics1.units.length, 1);
+      assert.equal(metrics1.units[0].id, "M001/S01/T01");
+      assert.equal(metrics2.units.length, 1);
+      assert.equal(metrics2.units[0].id, "M002/S01/T01");
+
+      resetMetricsByScope(scope1);
+      resetMetricsByScope(scope2);
+    } finally {
+      rmSync(projectDir2, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("ByScope works without calling initMetrics", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    // Deliberately do NOT call initMetrics / resetMetrics
+  });
+
+  afterEach(() => {
+    resetMetrics();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("snapshotUnitMetricsByScope succeeds without initMetrics having been called", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+    const ctx = mockCtx([assistantMsg()]);
+
+    // Confirm singleton was never initialized
+    assert.equal(getLedger(), null, "module singleton should be null — initMetrics was never called");
+
+    const unit = snapshotUnitMetricsByScope(
+      scope,
+      ctx,
+      "execute-task",
+      "M001/S01/T01",
+      Date.now() - 2000,
+      "test-model",
+    );
+    assert.ok(unit, "snapshotUnitMetricsByScope should return a unit");
+    assert.equal(unit!.id, "M001/S01/T01");
+
+    // Verify on disk
+    const raw = readFileSync(join(projectDir, ".gsd", "metrics.json"), "utf-8");
+    const parsed: MetricsLedger = JSON.parse(raw);
+    assert.equal(parsed.units.length, 1);
+
+    resetMetricsByScope(scope);
+  });
+
+  test("initMetricsByScope succeeds without initMetrics having been called", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+
+    assert.equal(getLedger(), null);
+
+    initMetricsByScope(scope);
+    const l = getLedgerByScope(scope);
+    assert.ok(l, "getLedgerByScope should return a ledger after initMetricsByScope");
+    assert.equal(l!.version, 1);
+    assert.equal(l!.units.length, 0);
+
+    resetMetricsByScope(scope);
+  });
+});
+
+describe("ByScope atomic write-merge — concurrent writers do not clobber", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    resetMetrics();
+  });
+
+  afterEach(() => {
+    resetMetrics();
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  // Worker script: same lock+merge semantics as saveLedger, written in plain CJS
+  // so it can run as a child process without loading the full extension tree.
+  const MERGE_WORKER = `
+const { openSync, closeSync, unlinkSync, existsSync, readFileSync, mkdirSync, renameSync } = require('node:fs');
+const { dirname } = require('node:path');
+const { randomBytes } = require('node:crypto');
+
+const metricsPath = process.env.GSD_SCOPE_METRICS_PATH;
+const milestoneId = process.env.GSD_SCOPE_MILESTONE_ID;
+const lockPath = metricsPath + '.lock';
+
+function acquireLock(lp, ms) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    try { const fd = openSync(lp, 'wx'); closeSync(fd); return true; }
+    catch { const w = Date.now() + Math.min(50, deadline - Date.now()); while (Date.now() < w) {} }
+  }
+  return false;
+}
+function releaseLock(lp) { try { unlinkSync(lp); } catch {} }
+function saveAtomic(fp, data) {
+  mkdirSync(dirname(fp), { recursive: true });
+  const tmp = fp + '.tmp.' + randomBytes(4).toString('hex');
+  require('node:fs').writeFileSync(tmp, JSON.stringify(data, null, 2) + '\\n', 'utf-8');
+  renameSync(tmp, fp);
+}
+function dedup(units) {
+  const m = new Map();
+  for (const u of units) {
+    const k = u.type + '\\0' + u.id + '\\0' + u.startedAt;
+    const e = m.get(k);
+    if (!e || u.finishedAt > e.finishedAt) m.set(k, u);
+  }
+  return Array.from(m.values());
+}
+
+const unit = {
+  type: 'execute-task', id: milestoneId + '/S01/T01', model: 'test',
+  startedAt: 1000, finishedAt: Date.now(),
+  tokens: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, total: 15 },
+  cost: 0.001, toolCalls: 0, assistantMessages: 1, userMessages: 1,
+};
+const workerLedger = { version: 1, projectStartedAt: 1000, units: [unit] };
+
+const acquired = acquireLock(lockPath, 5000);
+try {
+  let diskUnits = [];
+  if (existsSync(metricsPath)) {
+    try { const p = JSON.parse(readFileSync(metricsPath, 'utf-8')); if (p && Array.isArray(p.units)) diskUnits = p.units; } catch {}
+  }
+  saveAtomic(metricsPath, { ...workerLedger, units: dedup([...diskUnits, ...workerLedger.units]) });
+} finally {
+  if (acquired) releaseLock(lockPath);
+}
+`;
+
+  function spawnMergeWorker(metricsPath: string, milestoneId: string): void {
+    const result = spawnSync(process.execPath, ["-e", MERGE_WORKER], {
+      env: {
+        ...process.env,
+        GSD_SCOPE_METRICS_PATH: metricsPath,
+        GSD_SCOPE_MILESTONE_ID: milestoneId,
+      },
+      encoding: "utf-8",
+      timeout: 10_000,
+    });
+    if (result.error) throw result.error;
+    if (result.status !== 0) {
+      throw new Error(`Worker for ${milestoneId} failed:\n${result.stderr}`);
+    }
+  }
+
+  test("snapshotUnitMetricsByScope preserves a pre-existing entry written by a concurrent worker", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M002");
+    const metricsPath = join(ws.projectRoot, ".gsd", "metrics.json");
+
+    // Simulate a concurrent worker that already wrote M001's entry to disk
+    spawnMergeWorker(metricsPath, "M001");
+
+    // Now write M002 via scope variant — must preserve M001's entry
+    const ctx = mockCtx([assistantMsg()]);
+    snapshotUnitMetricsByScope(
+      scope,
+      ctx,
+      "execute-task",
+      "M002/S01/T01",
+      Date.now() - 2000,
+      "test-model",
+    );
+
+    const raw = readFileSync(metricsPath, "utf-8");
+    const parsed: MetricsLedger = JSON.parse(raw);
+    assert.equal(parsed.units.length, 2, "both M001 and M002 units must be in metrics.json");
+
+    const ids = parsed.units.map((u: UnitMetrics) => u.id);
+    assert.ok(ids.some((id) => id.startsWith("M001")), "M001 unit must be preserved");
+    assert.ok(ids.some((id) => id.startsWith("M002")), "M002 unit must be present");
+
+    resetMetricsByScope(scope);
+  });
+
+  test("idempotent ByScope snapshot does not duplicate units on disk", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+    const ctx = mockCtx([assistantMsg()]);
+    const startedAt = Date.now() - 3000;
+    const metricsPath = join(ws.projectRoot, ".gsd", "metrics.json");
+
+    // Snapshot twice with same type+id+startedAt
+    snapshotUnitMetricsByScope(scope, ctx, "execute-task", "M001/S01/T01", startedAt, "test-model");
+    snapshotUnitMetricsByScope(scope, ctx, "execute-task", "M001/S01/T01", startedAt, "test-model");
+
+    const parsed: MetricsLedger = JSON.parse(readFileSync(metricsPath, "utf-8"));
+    assert.equal(parsed.units.length, 1, "duplicate snapshots must not create duplicate entries");
+
+    resetMetricsByScope(scope);
+  });
+});

package/src/resources/extensions/gsd/tests/milestone-id-gap-reuse-4996.test.ts

@@ -0,0 +1,152 @@
+// GSD Extension — Regression test for #4996: ghost milestone ID reuse
+// Verifies that isReusableGhostMilestone correctly identifies reclaim-safe stub dirs,
+// and that nextMilestoneIdReserved (guided-flow) prefers the lowest reusable ghost
+// over max+1. Also covers the race-window regression: a queued DB row must NOT be reused.
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { isReusableGhostMilestone } from "../state.ts";
+import { nextMilestoneIdReserved } from "../milestone-id-reservation.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+import { clearReservedMilestoneIds, findMilestoneIds } from "../milestone-ids.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+function makeBase(prefix = "gsd-gap-4996-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function stubDir(base: string, mid: string): void {
+  // Create an empty stub — the phantom pattern
+  mkdirSync(join(base, ".gsd", "milestones", mid, "slices"), { recursive: true });
+}
+
+function populateDir(base: string, mid: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-CONTEXT.md`), `# ${mid} Context\n`);
+}
+
+describe("isReusableGhostMilestone (#4996)", () => {
+  let base: string;
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    try { invalidateAllCaches(); } catch { /* ignore */ }
+    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("(a) fails closed when the DB is unavailable", () => {
+    base = makeBase();
+    stubDir(base, "M003");
+    assert.equal(isReusableGhostMilestone(base, "M003"), false, "closed DB should block reusable-ghost claims");
+  });
+
+  it("(b) empty stub dir with an open DB and no DB row is reusable", () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    stubDir(base, "M003");
+    assert.ok(isReusableGhostMilestone(base, "M003"), "empty stub with no DB row should be reusable");
+  });
+
+  it("(c) queued DB row with no content must NOT be reusable (race window regression)", () => {
+    base = makeBase();
+    stubDir(base, "M003");
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M003", status: "queued" });
+    // Even though no content files exist, the queued DB row means an in-flight discuss
+    // is reserving this ID — it must not be reclaimed.
+    assert.ok(!isReusableGhostMilestone(base, "M003"), "queued DB row must block reuse");
+  });
+
+  it("(d) populated milestone dir is not reusable", () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    populateDir(base, "M001");
+    assert.ok(!isReusableGhostMilestone(base, "M001"), "populated dir must not be reusable");
+  });
+
+  it("(e) stub dir with worktree is not reusable (legitimate in-flight)", () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    stubDir(base, "M003");
+    // Simulate an existing worktree
+    mkdirSync(join(base, ".gsd", "worktrees", "M003"), { recursive: true });
+    assert.ok(!isReusableGhostMilestone(base, "M003"), "dir with worktree must not be reusable");
+  });
+
+  it("(f) active DB row makes dir not reusable", () => {
+    base = makeBase();
+    stubDir(base, "M003");
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M003", status: "active" });
+    assert.ok(!isReusableGhostMilestone(base, "M003"), "active DB row must block reuse");
+  });
+});
+
+describe("primary regression: M003/M004 stubs returned as next ID (#4996)", () => {
+  let base: string;
+
+  beforeEach(() => {
+    clearReservedMilestoneIds();
+  });
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    try { invalidateAllCaches(); } catch { /* ignore */ }
+    try { clearReservedMilestoneIds(); } catch { /* ignore */ }
+    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("M001/M002 populated + M003/M004 stubs → isReusableGhostMilestone returns true for M003 and M004", () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    populateDir(base, "M001");
+    populateDir(base, "M002");
+    stubDir(base, "M003");
+    stubDir(base, "M004");
+
+    assert.ok(isReusableGhostMilestone(base, "M003"), "M003 should be identified as reusable ghost");
+    assert.ok(isReusableGhostMilestone(base, "M004"), "M004 should be identified as reusable ghost");
+    assert.ok(!isReusableGhostMilestone(base, "M001"), "M001 should not be reusable");
+    assert.ok(!isReusableGhostMilestone(base, "M002"), "M002 should not be reusable");
+
+    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
+    assert.equal(nextId, "M003", "ID reservation should select the lowest reusable ghost");
+  });
+
+  it("when all dirs are populated, no ghost exists and the function returns false for all", () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    populateDir(base, "M001");
+    populateDir(base, "M002");
+
+    assert.ok(!isReusableGhostMilestone(base, "M001"), "M001 is populated, not reusable");
+    assert.ok(!isReusableGhostMilestone(base, "M002"), "M002 is populated, not reusable");
+
+    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
+    assert.equal(nextId, "M003", "ID reservation should fall back to max+1 when no ghost is reusable");
+  });
+
+  it("does not return an already-reserved reusable ghost twice", () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    stubDir(base, "M001");
+
+    const firstId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
+    const secondId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
+
+    assert.equal(firstId, "M001", "first reservation should reuse the ghost");
+    assert.equal(secondId, "M002", "second reservation must skip the already-reserved ghost");
+  });
+});

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

@@ -10,7 +10,7 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { _resolveReportBasePath } from "../auto/phases.ts";
+import { _resolveDispatchGuardBasePath, _resolveReportBasePath } from "../auto/phases.ts";
 
 describe("_resolveReportBasePath", () => {
   test("uses originalBasePath when set (worktree scenario)", () => {
@@ -48,4 +48,21 @@ describe("_resolveReportBasePath", () => {
 
     assert.equal(_resolveReportBasePath(session), "/home/user/repo");
   });
+
+  test("uses GSD_PROJECT_ROOT for symlink-resolved worktree paths", () => {
+    const savedProjectRoot = process.env.GSD_PROJECT_ROOT;
+    process.env.GSD_PROJECT_ROOT = "/real/project";
+    try {
+      const session = {
+        originalBasePath: "",
+        basePath: "/Users/dev/.gsd/projects/abc123/worktrees/M001/slices/S01",
+      };
+
+      assert.equal(_resolveReportBasePath(session), "/real/project");
+      assert.equal(_resolveDispatchGuardBasePath(session), "/real/project");
+    } finally {
+      if (savedProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+      else process.env.GSD_PROJECT_ROOT = savedProjectRoot;
+    }
+  });
 });

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

@@ -98,6 +98,25 @@ test("#4781 classifier: backend API mention → standard (not trivial)", () => {
   assert.strictEqual(r.variant, "standard");
 });
 
+test("#4781 classifier: negated backend/auth anti-goals do not override trivial static app", () => {
+  const r = classifyMilestoneScope({
+    title: "Local todo",
+    vision: "Single file static HTML app. No backend. No authentication. No API calls. Uses localStorage only.",
+    successCriteria: ["Add a task", "Mark complete", "Reload and keep tasks"],
+  });
+  assert.strictEqual(r.variant, "trivial", `reasons: ${r.reasons.join("; ")}`);
+});
+
+test("#4781 classifier: positive auth/backend requirements still route to standard", () => {
+  const r = classifyMilestoneScope({
+    title: "Todo accounts",
+    vision: "Add authentication and a backend API for syncing tasks.",
+    successCriteria: ["Users can log in", "Tasks sync through the API"],
+  });
+  assert.strictEqual(r.variant, "standard");
+  assert.ok(r.signals.triggeredOverride);
+});
+
 test("#4781 classifier: tests mentioned → standard (not trivial)", () => {
   const r = classifyMilestoneScope({
     title: "Landing page",