@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -1917,6 +1917,41 @@ test("#57: writeReactiveExecuteBlocker reconciles batch task statuses and append
   }
 });
 
+test("#1088: writeReactiveExecuteBlocker preserves deferred batch task statuses", () => {
+  const base = makeTmpBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "One", status: "deferred" });
+    insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Two", status: "deferred" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+      "# T01 Summary\n",
+      "utf-8",
+    );
+
+    const recovery = writeReactiveExecuteBlocker(
+      "M001/S01/reactive+T01,T02",
+      base,
+      "verification retries exhausted",
+    );
+
+    assert.ok(recovery, "recovery should run with DB available");
+    assert.deepEqual(recovery!.completedTaskIds, []);
+    assert.deepEqual(recovery!.skippedTaskIds, []);
+    assert.deepEqual(recovery!.unchangedTaskIds, ["T01", "T02"]);
+    assert.equal(getTask("M001", "S01", "T01")?.status, "deferred");
+    assert.equal(getTask("M001", "S01", "T02")?.status, "deferred");
+
+    const events = readEvents(join(base, ".gsd", "event-log.jsonl"));
+    assert.equal(events.some((e) => e.params.taskId === "T01" || e.params.taskId === "T02"), false);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("#4414: verifyExpectedArtifact parallel-research succeeds when all research-ready slices have RESEARCH", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/auto-remote-session-lock-cleanup.test.ts

@@ -124,3 +124,44 @@ test("forceStopAutoRemote escalates a live remote PID and releases worker state"
   );
   assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
 });
+
+test("forceStopAutoRemote does not SIGKILL a PID that exits during the grace window", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const pid = 525_252;
+  setWorkerPid(workerId, pid);
+  writeLegacyLock(base, pid);
+
+  // The process is alive until it receives SIGTERM, then exits cooperatively
+  // (liveness probe throws ESRCH) — so the grace loop should break before SIGKILL.
+  const signals: Array<NodeJS.Signals | 0> = [];
+  let alive = true;
+  const originalKill = process.kill;
+  process.kill = ((target: number, signal?: NodeJS.Signals | number) => {
+    assert.equal(target, pid);
+    if (signal === 0) {
+      if (!alive) {
+        const err = new Error("no such process") as NodeJS.ErrnoException;
+        err.code = "ESRCH";
+        throw err;
+      }
+      return true;
+    }
+    signals.push((signal ?? 0) as NodeJS.Signals | 0);
+    if (signal === "SIGTERM") alive = false; // cooperative exit on SIGTERM
+    return true;
+  }) as typeof process.kill;
+  t.after(() => {
+    process.kill = originalKill;
+  });
+
+  const result = forceStopAutoRemote(base);
+
+  assert.deepEqual(result, { found: true, pid });
+  assert.ok(signals.includes("SIGTERM"), "force stop should request graceful termination first");
+  assert.ok(!signals.includes("SIGKILL"), "force stop must not escalate when the PID exits during the grace window");
+  assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
+});

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -15,15 +15,21 @@
 
 import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   resetEvidence,
   getEvidence,
   recordToolCall,
   recordToolResult,
+  saveEvidenceToDisk,
   type BashEvidence,
 } from "../safety/evidence-collector.js";
 
+const waitForMtimeTick = () => new Promise(resolve => setTimeout(resolve, 25));
+
 describe("evidence-collector: toolCallId-based matching (A-3)", () => {
   beforeEach(() => {
     resetEvidence();
@@ -119,4 +125,28 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
     assert.equal(entries[1].kind, "bash");
     assert.equal(entries[1].command, "rg TODO");
   });
+
+  it("skips byte-identical evidence file rewrites", async (t) => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-evidence-dedupe-"));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+
+    recordToolCall("tc-bash-1", "bash", { command: "pnpm test" });
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+
+    const evidenceFile = join(base, ".gsd", "safety", "evidence-M001-S01-T03.json");
+    const firstMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    await waitForMtimeTick();
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+    const secondMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    assert.equal(secondMtime, firstMtime, "unchanged evidence must not rewrite the evidence file");
+
+    await waitForMtimeTick();
+    recordToolResult("tc-bash-1", "bash", "Command exited with code 0\nok\n", false);
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+    const thirdMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    assert.ok(thirdMtime > secondMtime, "changed evidence must still be persisted");
+  });
 });

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

@@ -3,6 +3,9 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   autoSession,
@@ -11,6 +14,10 @@ import {
   getAutoRuntimeSnapshot,
   recordAutoToolSurfaceSnapshot,
 } from "../auto-runtime-state.ts";
+import {
+  readUnitHarnessAbort,
+  recordUnitHarnessAbort,
+} from "../unit-runtime.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
@@ -81,6 +88,40 @@ test("clearToolInvocationError clears stale tool error state for active auto ses
   autoSession.reset();
 });
 
+test("clearToolInvocationError clears stale tool error even when a harness abort is durable", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-auto-runtime-state-"));
+  const startedAt = 123456;
+  try {
+    autoSession.reset();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.setCurrentUnit({
+      type: "gate-evaluate",
+      id: "M001/S01/gates+Q3",
+      startedAt,
+      workspaceRoot: base,
+    });
+    autoSession.lastToolInvocationError = "gsd_save_gate_result: simulated stale tool error";
+    recordUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt, {
+      kind: "tool-error",
+      reason: "Tool execution failed before the unit could complete its gate evaluation.",
+      toolName: "gsd_uat_exec",
+    });
+
+    clearToolInvocationError();
+
+    assert.equal(autoSession.lastToolInvocationError, null);
+    assert.equal(
+      readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt)?.kind,
+      "tool-error",
+      "durable harness abort remains available for result-save blocking",
+    );
+  } finally {
+    autoSession.reset();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
   autoSession.reset();
 

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

@@ -121,8 +121,8 @@ describe("AutoSession.scope — project mode (basePath equals originalBasePath)"
 
     assert.ok(s.scope, "scope should be set");
     const gsd = join(projectDir, ".gsd");
-    assert.equal(s.scope.contextFile(), join(gsd, "milestones", mid, `${mid}-CONTEXT.md`));
-    assert.equal(s.scope.roadmapFile(), join(gsd, "milestones", mid, `${mid}-ROADMAP.md`));
+    assert.equal(s.scope.contextFile(), join(gsd, "phases", "02-m002", "02-CONTEXT.md"));
+    assert.equal(s.scope.roadmapFile(), join(gsd, "phases", "02-m002", "02-ROADMAP.md"));
     assert.equal(s.scope.stateFile(), join(gsd, "STATE.md"));
   });
 });
@@ -236,8 +236,8 @@ describe("AutoSession.scope — milestoneId change rebuilds scope", () => {
     assert.ok(ctxM001, "M001 contextFile should be set");
     assert.ok(ctxM002, "M002 contextFile should be set");
     assert.notEqual(ctxM001, ctxM002, "contextFile must differ between milestone IDs");
-    assert.ok(ctxM001.includes("M001"), "M001 path should contain M001");
-    assert.ok(ctxM002.includes("M002"), "M002 path should contain M002");
+    assert.ok(ctxM001.includes("01-m001"), "M001 path should contain its phase directory");
+    assert.ok(ctxM002.includes("02-m002"), "M002 path should contain its phase directory");
   });
 });
 

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -17,14 +17,17 @@ import {
   clearPendingAutoStart,
   setPendingAutoStart,
 } from "../guided-flow.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
 test.afterEach(() => {
+  closeDatabase();
   clearPendingAutoStart();
 });
 
 test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before re-entering auto-mode", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-bootstrap-await-"));
   const notifications: string[] = [];
+  openDatabase(":memory:");
   t.after(() => rmSync(base, { recursive: true, force: true }));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
   setPendingAutoStart(base, {

package/src/resources/extensions/gsd/tests/auto-timeout-recovery-harness-abort.test.ts

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { recoverTimedOutUnit } from "../auto-timeout-recovery.ts";
+import {
+  readUnitHarnessAbort,
+  readUnitRuntimeRecord,
+  recordUnitHarnessAbort,
+} from "../unit-runtime.ts";
+
+test("timeout recovery retry clears stale harness abort for the same unit run", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-recovery-abort-"));
+  const startedAt = Date.now();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  try {
+    recordUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt, {
+      kind: "turn-abort",
+      reason: "Agent turn aborted before the unit could complete its gate evaluation.",
+    });
+    assert.equal(
+      readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt)?.kind,
+      "turn-abort",
+      "test setup should start with an abort marker",
+    );
+
+    const messages: Array<{ message: unknown; options: unknown }> = [];
+    const notifications: Array<{ message: string; level?: string }> = [];
+    const result = await recoverTimedOutUnit(
+      { ui: { notify: (message: string, level?: string) => notifications.push({ message, level }) } } as any,
+      { sendMessage: (message: unknown, options: unknown) => messages.push({ message, options }) } as any,
+      "gate-evaluate",
+      "M001/S01/gates+Q3",
+      "idle",
+      {
+        basePath: base,
+        verbose: false,
+        currentUnitStartedAt: startedAt,
+        unitRecoveryCount: new Map(),
+      },
+    );
+
+    assert.equal(result, "recovered");
+    assert.equal(readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt), null);
+    const record = readUnitRuntimeRecord(base, "gate-evaluate", "M001/S01/gates+Q3");
+    assert.equal(record?.phase, "recovered");
+    assert.equal(record?.lastProgressKind, "idle-recovery-retry");
+    assert.equal(messages.length, 1, "retry recovery should send one steering message");
+    assert.equal(notifications.length, 1, "retry recovery should notify once");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -34,6 +34,11 @@ import {
   clearPendingAutoStart,
   setPendingAutoStart,
 } from "../guided-flow.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
 
 // ─── Bug 2: this-binding regression ─────────────────────────────────────
 
@@ -89,6 +94,8 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
     mkdirSync(milestoneDir, { recursive: true });
     writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# Context\n", "utf-8");
     writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "M001", status: "queued" });
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
@@ -110,6 +117,7 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
       },
     ]);
   } finally {
+    closeDatabase();
     clearPendingAutoStart(base);
     rmSync(base, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/batch-task-query.test.ts

@@ -0,0 +1,85 @@
+// batch-task-query.test.ts
+// Verifies getTasksBySliceIds batches tasks correctly and matches the per-slice
+// getSliceTasks path (guards the projection N+1 fix).
+
+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,
+  insertSlice,
+  insertTask,
+  getSliceTasks,
+  getTasksBySliceIds,
+} from "../gsd-db.ts";
+
+function withDb(fn: () => void): void {
+  const base = mkdtempSync(join(tmpdir(), "gsd-batch-task-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    fn();
+  } finally {
+    try { closeDatabase(); } catch {}
+    try { rmSync(base, { recursive: true, force: true }); } catch {}
+  }
+}
+
+function seed(): void {
+  insertMilestone({ id: "M001", title: "M1", status: "active" });
+  insertMilestone({ id: "M002", title: "M2", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "S1", status: "active", risk: "low", depends: [] });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "S2", status: "pending", risk: "low", depends: [] });
+  insertSlice({ id: "S01", milestoneId: "M002", title: "S1", status: "active", risk: "low", depends: [] });
+  // M001/S01 has two tasks; M001/S02 has one; M002/S01 has none.
+  insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "second", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "first", status: "complete" });
+  insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "only", status: "pending" });
+}
+
+const key = (m: string, s: string) => `${m}\0${s}`;
+
+test("getTasksBySliceIds buckets tasks per (milestone, slice)", () => {
+  withDb(() => {
+    seed();
+    const map = getTasksBySliceIds([
+      { milestoneId: "M001", sliceId: "S01" },
+      { milestoneId: "M001", sliceId: "S02" },
+      { milestoneId: "M002", sliceId: "S01" },
+    ]);
+    assert.equal(map.get(key("M001", "S01"))?.length, 2);
+    assert.equal(map.get(key("M001", "S02"))?.length, 1);
+    // A slice with no tasks is absent (caller falls back to []).
+    assert.equal(map.has(key("M002", "S01")), false);
+  });
+});
+
+test("getTasksBySliceIds preserves ORDER BY sequence, id within a bucket", () => {
+  withDb(() => {
+    seed();
+    const bucket = getTasksBySliceIds([{ milestoneId: "M001", sliceId: "S01" }]).get(key("M001", "S01"));
+    // Insertion order was T02 then T01; ordering is by sequence then id, so T01 first.
+    assert.deepEqual(bucket?.map((t) => t.id), ["T01", "T02"]);
+  });
+});
+
+test("getTasksBySliceIds equals getSliceTasks for a single slice", () => {
+  withDb(() => {
+    seed();
+    const batched = getTasksBySliceIds([{ milestoneId: "M001", sliceId: "S01" }]).get(key("M001", "S01"));
+    const direct = getSliceTasks("M001", "S01");
+    assert.deepEqual(batched, direct);
+  });
+});
+
+test("getTasksBySliceIds returns an empty map for empty input", () => {
+  withDb(() => {
+    seed();
+    assert.equal(getTasksBySliceIds([]).size, 0);
+  });
+});

package/src/resources/extensions/gsd/tests/check-auto-start-ready-guard.test.ts

@@ -13,6 +13,7 @@ import {
   checkAutoStartAfterDiscuss,
   setPendingAutoStart,
   clearPendingAutoStart,
+  _getPendingAutoStart,
 } from "../guided-flow.ts";
 import { drainLogs } from "../workflow-logger.ts";
 import {
@@ -77,6 +78,7 @@ describe("checkAutoStartAfterDiscuss ready-notify DB guard (R3b)", () => {
   let cap: MockCapture;
 
   beforeEach(() => {
+    closeDatabase();
     clearPendingAutoStart();
     drainLogs();
   });
@@ -129,6 +131,33 @@ describe("checkAutoStartAfterDiscuss ready-notify DB guard (R3b)", () => {
     ]);
   });
 
+  test("fails closed and keeps pending handoff when DB is unavailable", () => {
+    base = mkBase();
+    closeDatabase();
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      startAuto: false,
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "DB-unavailable handoff must fail closed");
+    assert.equal(
+      _getPendingAutoStart(base)?.milestoneId,
+      "M001",
+      "failed closed handoff must remain pending for a later retry",
+    );
+    assert.equal(
+      cap.notifies.some(n => n.level === "success"),
+      false,
+      "must not notify success before the milestone row is verified",
+    );
+  });
+
   test("announces 'ready' when DB row has executable slices", () => {
     base = mkBase();
     openDatabase(":memory:");