gsd-pi 2.48.0-dev.ced2eca → 2.49.0-dev.9e177e9

package/src/resources/extensions/gsd/tests/gate-dispatch.test.ts

@@ -0,0 +1,189 @@
+// Quality gate dispatch + state derivation tests
+// Verifies the evaluating-gates phase and dispatch rule behavior.
+
+import { describe, test, 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 {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  upsertSlicePlanning,
+  upsertTaskPlanning,
+  insertGateRow,
+  saveGateResult,
+  markAllGatesOmitted,
+  getPendingSliceGateCount,
+} from "../gsd-db.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
+import { renderPlanFromDb } from "../markdown-renderer.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+function setupTestProject(): { tmpDir: string; dbPath: string } {
+  const tmpDir = mkdtempSync(join(tmpdir(), "gate-dispatch-"));
+  const dbPath = join(tmpDir, ".gsd", "gsd.db");
+  mkdirSync(join(tmpDir, ".gsd"), { recursive: true });
+  openDatabase(dbPath);
+
+  // Create milestone
+  insertMilestone({
+    id: "M001",
+    title: "Test Milestone",
+    status: "active",
+  });
+
+  // Create slice
+  insertSlice({
+    milestoneId: "M001",
+    id: "S01",
+    title: "Test Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+  });
+
+  // Write roadmap file (required for deriveState)
+  const milestoneDir = join(tmpDir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "## Vision",
+      "Test milestone vision.",
+      "",
+      "## Success Criteria",
+      "- Test criteria",
+      "",
+      "## Delivery Sequence",
+      "- [ ] **S01: Test Slice** `risk:medium`",
+      "  After this: test demo",
+      "",
+    ].join("\n"),
+  );
+
+  return { tmpDir, dbPath };
+}
+
+function planSlice(tmpDir: string) {
+  upsertSlicePlanning("M001", "S01", {
+    goal: "Test goal",
+    successCriteria: "Test criteria",
+    proofLevel: "contract",
+    integrationClosure: "",
+    observabilityImpact: "Run tests",
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Test Task",
+    status: "pending",
+  });
+  upsertTaskPlanning("M001", "S01", "T01", {
+    title: "Test Task",
+    description: "Implement test",
+    estimate: "1h",
+    files: ["src/test.ts"],
+    verify: "npm test",
+    inputs: [],
+    expectedOutput: ["src/test.ts"],
+    observabilityImpact: "",
+    fullPlanMd: "",
+  });
+}
+
+describe("evaluating-gates phase", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    const setup = setupTestProject();
+    tmpDir = setup.tmpDir;
+  });
+
+  afterEach(() => {
+    invalidateAllCaches();
+    invalidateStateCache();
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("state returns evaluating-gates when slice gates are pending", async () => {
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    // Seed gates as pending
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+
+    invalidateStateCache();
+    const state = await deriveState(tmpDir);
+    assert.equal(state.phase, "evaluating-gates");
+    assert.ok(state.nextAction.includes("quality gate"));
+  });
+
+  test("state returns executing when all gates are resolved", async () => {
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+
+    saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", verdict: "pass", rationale: "OK", findings: "" });
+    saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", verdict: "omitted", rationale: "N/A", findings: "" });
+
+    invalidateStateCache();
+    const state = await deriveState(tmpDir);
+    assert.equal(state.phase, "executing");
+  });
+
+  test("state returns executing when no gates exist (backward compat)", async () => {
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    // No gates seeded at all
+    invalidateStateCache();
+    const state = await deriveState(tmpDir);
+    assert.equal(state.phase, "executing");
+  });
+
+  test("markAllGatesOmitted clears evaluating-gates phase", async () => {
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+
+    invalidateStateCache();
+    assert.equal((await deriveState(tmpDir)).phase, "evaluating-gates");
+
+    markAllGatesOmitted("M001", "S01");
+    invalidateStateCache();
+    assert.equal((await deriveState(tmpDir)).phase, "executing");
+  });
+
+  test("task-scoped gates do not block evaluating-gates phase", async () => {
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    // Only task-scoped gates — no slice-scoped gates
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+
+    invalidateStateCache();
+    const state = await deriveState(tmpDir);
+    // Should be executing, not evaluating-gates, because Q5 is task-scoped
+    assert.equal(state.phase, "executing");
+  });
+
+  test("getPendingSliceGateCount ignores task-scoped gates", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+    assert.equal(getPendingSliceGateCount("M001", "S01"), 1);
+  });
+});

package/src/resources/extensions/gsd/tests/gate-storage.test.ts

@@ -0,0 +1,156 @@
+// Quality gate DB storage tests
+// Verifies CRUD operations on the quality_gates table.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertGateRow,
+  saveGateResult,
+  getPendingGates,
+  getGateResults,
+  markAllGatesOmitted,
+  getPendingSliceGateCount,
+  insertMilestone,
+  insertSlice,
+} from "../gsd-db.ts";
+
+describe("quality_gates CRUD", () => {
+  let tmpDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "gate-test-"));
+    dbPath = join(tmpDir, "gsd.db");
+    openDatabase(dbPath);
+    // Seed parent rows
+    insertMilestone({
+      id: "M001",
+      title: "Test Milestone",
+      status: "active",
+    });
+    insertSlice({
+      milestoneId: "M001",
+      id: "S01",
+      title: "Test Slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+    });
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("insertGateRow creates a pending gate", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    const pending = getPendingGates("M001", "S01");
+    assert.equal(pending.length, 1);
+    assert.equal(pending[0].gate_id, "Q3");
+    assert.equal(pending[0].status, "pending");
+    assert.equal(pending[0].scope, "slice");
+  });
+
+  test("insertGateRow with INSERT OR IGNORE is idempotent", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    const all = getGateResults("M001", "S01");
+    assert.equal(all.length, 1);
+  });
+
+  test("saveGateResult updates status and verdict", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    saveGateResult({
+      milestoneId: "M001",
+      sliceId: "S01",
+      gateId: "Q3",
+      verdict: "pass",
+      rationale: "No auth surface",
+      findings: "This slice has no user-facing endpoints.",
+    });
+    const results = getGateResults("M001", "S01");
+    assert.equal(results.length, 1);
+    assert.equal(results[0].status, "complete");
+    assert.equal(results[0].verdict, "pass");
+    assert.equal(results[0].rationale, "No auth surface");
+    assert.ok(results[0].evaluated_at);
+  });
+
+  test("getPendingGates filters by scope", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+
+    const sliceGates = getPendingGates("M001", "S01", "slice");
+    assert.equal(sliceGates.length, 1);
+    assert.equal(sliceGates[0].gate_id, "Q3");
+
+    const taskGates = getPendingGates("M001", "S01", "task");
+    assert.equal(taskGates.length, 1);
+    assert.equal(taskGates[0].gate_id, "Q5");
+  });
+
+  test("markAllGatesOmitted marks all pending gates as omitted", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+
+    markAllGatesOmitted("M001", "S01");
+
+    const pending = getPendingGates("M001", "S01");
+    assert.equal(pending.length, 0);
+
+    const all = getGateResults("M001", "S01");
+    assert.equal(all.length, 3);
+    for (const g of all) {
+      assert.equal(g.status, "omitted");
+      assert.equal(g.verdict, "omitted");
+    }
+  });
+
+  test("getPendingSliceGateCount returns correct count", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+
+    assert.equal(getPendingSliceGateCount("M001", "S01"), 2);
+
+    saveGateResult({
+      milestoneId: "M001", sliceId: "S01", gateId: "Q3",
+      verdict: "pass", rationale: "OK", findings: "",
+    });
+    assert.equal(getPendingSliceGateCount("M001", "S01"), 1);
+  });
+
+  test("task-scoped gates with different task_id are distinct", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T02" });
+
+    const all = getGateResults("M001", "S01", "task");
+    assert.equal(all.length, 2);
+  });
+
+  test("getGateResults returns empty for nonexistent slice", () => {
+    const results = getGateResults("M001", "S99");
+    assert.equal(results.length, 0);
+  });
+
+  test("saveGateResult with flag verdict preserves findings", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    saveGateResult({
+      milestoneId: "M001", sliceId: "S01", gateId: "Q4",
+      verdict: "flag", rationale: "Breaks R003",
+      findings: "## R003 Impact\n\n- Login flow must be re-tested\n- Session token format changed",
+    });
+    const results = getGateResults("M001", "S01", "slice");
+    const q4 = results.find(g => g.gate_id === "Q4")!;
+    assert.equal(q4.verdict, "flag");
+    assert.ok(q4.findings.includes("R003 Impact"));
+  });
+});

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -868,6 +868,55 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  // ─── writeIntegrationBranch: rejects workflow-template branches (#2498) ─
+
+  test('Integration branch: rejects workflow-template branches', () => {
+    const repo = initBranchTestRepo();
+
+    // All 8 registered workflow templates should be rejected
+    writeIntegrationBranch(repo, "M001", "gsd/hotfix/fix-login");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "hotfix branch is not recorded");
+
+    writeIntegrationBranch(repo, "M001", "gsd/bugfix/null-pointer");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "bugfix branch is not recorded");
+
+    writeIntegrationBranch(repo, "M001", "gsd/small-feature/add-button");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "small-feature branch is not recorded");
+
+    writeIntegrationBranch(repo, "M001", "gsd/refactor/rename-module");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "refactor branch is not recorded");
+
+    writeIntegrationBranch(repo, "M001", "gsd/spike/evaluate-lib");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "spike branch is not recorded");
+
+    writeIntegrationBranch(repo, "M001", "gsd/security-audit/owasp-scan");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "security-audit branch is not recorded");
+
+    writeIntegrationBranch(repo, "M001", "gsd/dep-upgrade/bump-react");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "dep-upgrade branch is not recorded");
+
+    writeIntegrationBranch(repo, "M001", "gsd/full-project/new-app");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "full-project branch is not recorded");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  // ─── writeIntegrationBranch: still records legitimate branches ────────
+
+  test('Integration branch: records non-ephemeral gsd branches', () => {
+    const repo = initBranchTestRepo();
+
+    // A normal feature branch should still be recorded
+    writeIntegrationBranch(repo, "M001", "feature/new-thing");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "feature/new-thing", "normal branches are recorded");
+
+    // The main branch should be recorded
+    writeIntegrationBranch(repo, "M002", "main");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), "main", "main branch is recorded");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: rejects invalid branch names ─────────────
 
   test('Integration branch: rejects invalid names', () => {

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

@@ -64,7 +64,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 11, 'schema version should be 11');
+    assert.deepStrictEqual(version?.['version'], 12, 'schema version should be 12');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

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

@@ -9,11 +9,11 @@ import { isInfrastructureError, INFRA_ERROR_CODES } from "../auto/infra-errors.j
 test("INFRA_ERROR_CODES contains the expected codes", () => {
   for (const code of [
     "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE", "ENFILE",
-    "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+    "EAGAIN", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
   ]) {
     assert.ok(INFRA_ERROR_CODES.has(code), `missing ${code}`);
   }
-  assert.equal(INFRA_ERROR_CODES.size, 9, "unexpected extra codes");
+  assert.equal(INFRA_ERROR_CODES.size, 10, "unexpected extra codes");
 });
 
 // ── isInfrastructureError: code property detection ───────────────────────────
@@ -48,6 +48,16 @@ test("detects ENFILE via code property", () => {
   assert.equal(isInfrastructureError(err), "ENFILE");
 });
 
+test("detects EAGAIN via code property", () => {
+  const err = Object.assign(new Error("resource temporarily unavailable"), { code: "EAGAIN" });
+  assert.equal(isInfrastructureError(err), "EAGAIN");
+});
+
+test("detects EAGAIN in error message fallback", () => {
+  const err = new Error("spawn failed: EAGAIN resource temporarily unavailable");
+  assert.equal(isInfrastructureError(err), "EAGAIN");
+});
+
 test("detects ECONNREFUSED via code property", () => {
   const err = Object.assign(new Error("connect ECONNREFUSED 127.0.0.1:3000"), { code: "ECONNREFUSED" });
   assert.equal(isInfrastructureError(err), "ECONNREFUSED");

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

@@ -505,3 +505,42 @@ test("milestone-transition event is emitted when milestone changes", async () =>
   assert.equal((transitionEvents[0].data as any).to, "M002");
   assert.equal(transitionEvents[0].flowId, ic.flowId);
 });
+
+test("unit-end event contains errorContext when unit is cancelled with structured error", async () => {
+  const capture = createEventCapture();
+  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto-loop.js");
+  _resetPendingResolve();
+
+  const deps = makeMockDeps(capture);
+  const ic = makeIC(deps);
+  const iterData: IterationData = {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    prompt: "do stuff",
+    finalPrompt: "do stuff",
+    pauseAfterUatDispatch: false,
+    state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
+    mid: "M001",
+    midTitle: "Test",
+    isRetry: false,
+    previousTier: undefined,
+  };
+  const loopState: LoopState = { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0 };
+
+  const unitPromise = runUnitPhase(ic, iterData, loopState);
+  await new Promise(r => setTimeout(r, 50));
+
+  // Resolve with errorContext (simulates a timeout cancel)
+  resolveAgentEndCancelled({ message: "Hard timeout error: exceeded limit", category: "timeout", isTransient: true });
+
+  const result = await unitPromise;
+  // Cancelled units break the loop before emitting unit-end
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "session-failed");
+
+  // Verify error classification used structured errorContext on the window entry
+  const entry = loopState.recentUnits[loopState.recentUnits.length - 1];
+  assert.ok(entry.error, "window entry must have error set");
+  assert.ok(entry.error!.startsWith("timeout:"), "error must start with category from errorContext");
+  assert.ok(entry.error!.includes("Hard timeout error"), "error must include the errorContext message");
+});

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 11, 'new DB should be at schema version 11');
+  assert.deepStrictEqual(version?.v, 12, 'new DB should be at schema version 12');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 11 (after state machine migration)
+  // Verify schema version is 12 (after quality gates table)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 11, 'schema version should be 11');
+  assert.deepStrictEqual(version?.['v'], 12, 'schema version should be 12');
 
   closeDatabase();
 });