gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/tests/runtime-kv.test.ts

@@ -0,0 +1,120 @@
+// gsd-2 + runtime_kv non-correctness-critical key-value storage tests (Phase C)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
+import {
+  setRuntimeKv,
+  getRuntimeKv,
+  deleteRuntimeKv,
+  listRuntimeKv,
+} from "../db/runtime-kv.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-runtime-kv-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("set + get round-trip preserves the value", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("global", "", "ui_cursor", { row: 5, col: 10 });
+  const got = getRuntimeKv<{ row: number; col: number }>("global", "", "ui_cursor");
+  assert.deepEqual(got, { row: 5, col: 10 });
+});
+
+test("get returns null for missing keys", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  assert.equal(getRuntimeKv("global", "", "missing"), null);
+});
+
+test("set on existing key updates the value (idempotent upsert)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("worker", "w1", "counter", 1);
+  setRuntimeKv("worker", "w1", "counter", 42);
+  assert.equal(getRuntimeKv("worker", "w1", "counter"), 42);
+});
+
+test("scope partitioning: same key under different scopes is independent", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("global", "", "k", "global-value");
+  setRuntimeKv("worker", "w1", "k", "worker-value");
+  setRuntimeKv("milestone", "M001", "k", "milestone-value");
+
+  assert.equal(getRuntimeKv("global", "", "k"), "global-value");
+  assert.equal(getRuntimeKv("worker", "w1", "k"), "worker-value");
+  assert.equal(getRuntimeKv("milestone", "M001", "k"), "milestone-value");
+});
+
+test("scope_id partitioning: same scope+key under different scope_ids is independent", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("worker", "w1", "k", "v1");
+  setRuntimeKv("worker", "w2", "k", "v2");
+  assert.equal(getRuntimeKv("worker", "w1", "k"), "v1");
+  assert.equal(getRuntimeKv("worker", "w2", "k"), "v2");
+});
+
+test("delete removes the row; subsequent get returns null", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("worker", "w1", "k", "value");
+  deleteRuntimeKv("worker", "w1", "k");
+  assert.equal(getRuntimeKv("worker", "w1", "k"), null);
+});
+
+test("list returns all rows for a scope+scope_id, ordered by key", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("milestone", "M001", "alpha", 1);
+  setRuntimeKv("milestone", "M001", "gamma", 3);
+  setRuntimeKv("milestone", "M001", "beta", 2);
+  setRuntimeKv("milestone", "M002", "ignored", "different-scope");
+
+  const rows = listRuntimeKv("milestone", "M001");
+  assert.equal(rows.length, 3);
+  assert.deepEqual(rows.map(r => r.key), ["alpha", "beta", "gamma"]);
+});
+
+test("malformed JSON in storage returns null without throwing", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  // Inject a malformed value directly (bypassing setRuntimeKv's JSON.stringify).
+  setRuntimeKv("global", "", "k", "valid");
+  // Then poison the row via raw SQL.
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE runtime_kv SET value_json = '{not json' WHERE scope = 'global' AND scope_id = '' AND key = 'k'`,
+  ).run();
+
+  assert.equal(getRuntimeKv("global", "", "k"), null);
+});

package/src/resources/extensions/gsd/tests/skipped-validation-completion.test.ts

@@ -1,39 +1,144 @@
 /**
  * Regression test for #3698 — allow milestone completion when validation
- * was skipped by preference
- *
- * When validation is skipped due to user preference (e.g. budget profile),
- * auto-dispatch should recognize the "skipped by preference" pattern and
- * allow completion instead of treating it as a missing validation.
+ * was skipped by preference.
  */
 
-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';
+import test 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";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+  upsertMilestonePlanning,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import type { GSDState } from "../types.ts";
 
-const autoDispatchSrc = readFileSync(
-  join(__dirname, '..', 'auto-dispatch.ts'),
-  'utf-8',
-);
+const COMPLETE_RULE = "completing-milestone → complete-milestone";
 
-describe('skipped validation completion (#3698)', () => {
-  test('skippedByPreference regex detection exists', () => {
-    assert.match(autoDispatchSrc, /skippedByPreference/,
-      'skippedByPreference variable should exist in auto-dispatch.ts');
-  });
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-skipped-validation-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(join(base, "app.js"), "export const shipped = true;\n");
+  return base;
+}
 
-  test('regex matches skip-by-preference patterns', () => {
-    assert.match(autoDispatchSrc, /skip\(\?:ped\)\?\[\\s\\-\]\+\(\?:by\|per\|due to\)/,
-      'should have regex matching "skipped by/per/due to" patterns');
-  });
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
 
-  test('skippedByPreference feeds into operational check', () => {
-    assert.match(autoDispatchSrc, /hasOperationalCheck\s*=\s*skippedByPreference/,
-      'skippedByPreference should be part of hasOperationalCheck');
+function seedMilestone(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({
+    id: "M001",
+    title: "Preference-skipped validation milestone",
+    status: "active",
+    depends_on: [],
+  });
+  upsertMilestonePlanning("M001", {
+    title: "Preference-skipped validation milestone",
+    status: "active",
+    vision: "Ship a small implementation with a documented validation skip.",
+    successCriteria: ["Completion remains unblocked when validation was intentionally skipped."],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "Smoke-test the shipped workflow before completion.",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
   });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "First",
+    status: "done",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+}
+
+function writeFixtureFiles(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(milestoneDir, "slices", "S01", "S01-SUMMARY.md"),
+    "# S01\n\nImplemented the shipped workflow.\n",
+  );
+  writeFileSync(
+    join(milestoneDir, "M001-VALIDATION.md"),
+    [
+      "---",
+      "verdict: pass",
+      "skip_validation: true",
+      "skip_validation_reason: preference",
+      "remediation_round: 0",
+      "---",
+      "",
+      "# Milestone Validation (skipped)",
+      "",
+      "Milestone validation was skipped by preference.",
+    ].join("\n"),
+  );
+}
+
+function findRule(name: string) {
+  const rule = DISPATCH_RULES.find(candidate => candidate.name === name);
+  assert.ok(rule, `rule "${name}" must exist`);
+  return rule!;
+}
+
+function makeCtx(base: string): DispatchContext {
+  const state: GSDState = {
+    phase: "completing-milestone",
+    activeMilestone: { id: "M001", title: "Preference-skipped validation milestone" },
+    activeSlice: null,
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [{ id: "M001", title: "Preference-skipped validation milestone", status: "active" }],
+  };
+  return {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Preference-skipped validation milestone",
+    state,
+    prefs: undefined,
+  };
+}
+
+test("#3698: completing-milestone dispatch accepts skipped validation fixture", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base);
+  writeFixtureFiles(base);
+
+  const result = await findRule(COMPLETE_RULE).match(makeCtx(base));
+
+  assert.ok(result, "rule must return a result");
+  assert.strictEqual(result!.action, "dispatch", "skipped validation should still allow completion dispatch");
+  if (result!.action === "dispatch") {
+    assert.strictEqual(result.unitType, "complete-milestone");
+  }
 });

package/src/resources/extensions/gsd/tests/skipped-validation-db-atomicity.test.ts

@@ -0,0 +1,17 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+test("skipped validation DB persistence stays atomic", () => {
+  const source = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+
+  assert.match(
+    source,
+    /if \(isDbAvailable\(\)\) \{\s+transaction\(\(\) => \{\s+insertAssessment\([\s\S]*?insertMilestoneValidationGates\(/,
+    "skipped validation DB writes must remain inside a single transaction",
+  );
+});

package/src/resources/extensions/gsd/tests/stuck-state-via-db.test.ts

@@ -0,0 +1,134 @@
+// gsd-2 + Stuck-state DB-migration regression (Phase C)
+//
+// stuck-state.json file IO has been deleted. The auto-loop now reconstructs
+// recentUnits from unit_dispatches (Phase B ledger) and persists
+// stuckRecoveryAttempts in runtime_kv (stable project scope, soft state).
+//
+// This test verifies the round-trip via the db modules directly: write
+// dispatch rows + a runtime_kv counter, then confirm the same data shape
+// the loop expects is returned.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import {
+  recordDispatchClaim,
+  getRecentUnitKeysForWorker,
+} from "../db/unit-dispatches.ts";
+import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stuck-state-db-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("getRecentUnitKeysForWorker reconstructs the recentUnits sliding window", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // Record three dispatches in chronological order. Each must transition
+  // out of 'claimed' before the next one with the same unit_id can claim
+  // (partial unique index). We use distinct unit IDs so all three coexist.
+  const claims: number[] = [];
+  for (const id of ["U1", "U2", "U3"]) {
+    const c = recordDispatchClaim({
+      traceId: id, workerId: worker, milestoneLeaseToken: lease.token,
+      milestoneId: "M001", unitType: "plan-slice", unitId: id,
+    });
+    assert.equal(c.ok, true);
+    if (c.ok) claims.push(c.dispatchId);
+  }
+
+  // The loader should return them oldest-first to match the in-memory
+  // window semantics that detect-stuck.ts expects.
+  const window = getRecentUnitKeysForWorker(worker, 20);
+  assert.deepEqual(window.map(w => w.key), ["U1", "U2", "U3"]);
+});
+
+test("getRecentUnitKeysForWorker honors the limit parameter", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  for (let i = 0; i < 25; i++) {
+    const c = recordDispatchClaim({
+      traceId: `t${i}`, workerId: worker, milestoneLeaseToken: lease.token,
+      milestoneId: "M001", unitType: "plan-slice", unitId: `U${i}`,
+    });
+    assert.equal(c.ok, true);
+  }
+
+  const win20 = getRecentUnitKeysForWorker(worker, 20);
+  assert.equal(win20.length, 20);
+  // Most recent 20 are U5..U24 (chronological), oldest-first → U5..U24.
+  assert.equal(win20[0].key, "U5");
+  assert.equal(win20[19].key, "U24");
+});
+
+test("stuckRecoveryAttempts round-trips via runtime_kv (stable project scope)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  registerAutoWorker({ projectRootRealpath: base });
+
+  setRuntimeKv("global", base, "stuck_recovery_attempts", 3);
+  assert.equal(getRuntimeKv<number>("global", base, "stuck_recovery_attempts"), 3);
+  setRuntimeKv("global", base, "stuck_recovery_attempts", 7);
+  assert.equal(getRuntimeKv<number>("global", base, "stuck_recovery_attempts"), 7);
+});
+
+test("getRecentUnitKeysForWorker filters by worker_id (no cross-worker bleed)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  insertMilestone({ id: "M002", title: "U", status: "active" });
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const w2 = registerAutoWorker({ projectRootRealpath: base });
+  const lease1 = claimMilestoneLease(w1, "M001");
+  const lease2 = claimMilestoneLease(w2, "M002");
+  assert.equal(lease1.ok, true);
+  assert.equal(lease2.ok, true);
+  if (!lease1.ok || !lease2.ok) return;
+
+  recordDispatchClaim({
+    traceId: "ta", workerId: w1, milestoneLeaseToken: lease1.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "for-w1",
+  });
+  recordDispatchClaim({
+    traceId: "tb", workerId: w2, milestoneLeaseToken: lease2.token,
+    milestoneId: "M002", unitType: "plan-slice", unitId: "for-w2",
+  });
+
+  const w1Window = getRecentUnitKeysForWorker(w1, 20);
+  const w2Window = getRecentUnitKeysForWorker(w2, 20);
+  assert.deepEqual(w1Window.map(w => w.key), ["for-w1"]);
+  assert.deepEqual(w2Window.map(w => w.key), ["for-w2"]);
+});