@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.553dc518

package/src/resources/extensions/gsd/tests/auto-worktree-merge-integration-branch.test.ts

@@ -0,0 +1,123 @@
+// gsd-pi — Regression tests for milestone merge integration-branch preparation.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetMergeIntegrationBranchDepsForTests,
+  _setMergeIntegrationBranchDepsForTests,
+  prepareIntegrationBranchForMilestoneMerge,
+} from "../auto-worktree-merge-integration-branch.js";
+import { GSDError } from "../errors.js";
+
+describe("prepareIntegrationBranchForMilestoneMerge", () => {
+  beforeEach(() => {
+    _resetMergeIntegrationBranchDepsForTests();
+  });
+
+  afterEach(() => {
+    _resetMergeIntegrationBranchDepsForTests();
+  });
+
+  test("falls back to detected main, clears transient state, and checks out the integration branch", () => {
+    const calls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({ reason: "missing metadata" } as never),
+      nativeDetectMainBranch: () => "develop",
+      nativeGetCurrentBranch: () => "feature/current",
+      nativeCheckoutBranch: (_basePath, branch) => {
+        calls.push(`checkout:${branch}`);
+      },
+      clearProjectRootStateFiles: (_basePath, milestoneId) => {
+        calls.push(`clear:${milestoneId}`);
+      },
+    });
+
+    const result = prepareIntegrationBranchForMilestoneMerge({
+      milestoneBranch: "milestone/M002",
+      milestoneId: "M002",
+      prefs: {},
+      previousCwd: "/repo/.gsd-worktrees/M002",
+      projectRoot: "/repo",
+    });
+
+    assert.equal(result.mainBranch, "develop");
+    assert.deepEqual(calls, ["clear:M002", "checkout:develop"]);
+  });
+
+  test("refuses self-merge and restores cwd", () => {
+    const chdirCalls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({
+        effectiveBranch: "refs/heads/milestone/M002",
+        reason: "corrupt metadata",
+      } as never),
+      chdir: (path) => {
+        chdirCalls.push(path);
+      },
+    });
+
+    assert.throws(
+      () => prepareIntegrationBranchForMilestoneMerge({
+        milestoneBranch: "milestone/M002",
+        milestoneId: "M002",
+        prefs: {},
+        previousCwd: "/repo/.gsd-worktrees/M002",
+        projectRoot: "/repo",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && /same ref as milestone branch/.test(err.message)
+        && /corrupt metadata/.test(err.message),
+    );
+    assert.deepEqual(chdirCalls, ["/repo/.gsd-worktrees/M002"]);
+  });
+
+  test("refuses detached project-root HEAD and restores cwd", () => {
+    const chdirCalls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({ effectiveBranch: "main", reason: "configured" } as never),
+      nativeGetCurrentBranch: () => "",
+      chdir: (path) => {
+        chdirCalls.push(path);
+      },
+    });
+
+    assert.throws(
+      () => prepareIntegrationBranchForMilestoneMerge({
+        milestoneBranch: "milestone/M002",
+        milestoneId: "M002",
+        prefs: {},
+        previousCwd: "/repo/.gsd-worktrees/M002",
+        projectRoot: "/repo",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && /detached HEAD state/.test(err.message),
+    );
+    assert.deepEqual(chdirCalls, ["/repo/.gsd-worktrees/M002"]);
+  });
+
+  test("does not checkout when the project root is already on the integration branch", () => {
+    const calls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({ effectiveBranch: "main", reason: "configured" } as never),
+      nativeGetCurrentBranch: () => "main",
+      nativeCheckoutBranch: () => {
+        calls.push("checkout");
+      },
+      clearProjectRootStateFiles: () => {
+        calls.push("clear");
+      },
+    });
+
+    const result = prepareIntegrationBranchForMilestoneMerge({
+      milestoneBranch: "milestone/M002",
+      milestoneId: "M002",
+      prefs: {},
+      previousCwd: "/repo/.gsd-worktrees/M002",
+      projectRoot: "/repo",
+    });
+
+    assert.equal(result.mainBranch, "main");
+    assert.deepEqual(calls, ["clear"]);
+  });
+});

package/src/resources/extensions/gsd/tests/auto-worktree-merge-message.test.ts

@@ -0,0 +1,114 @@
+// gsd-pi — Regression tests for milestone merge commit message construction.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetMilestoneMergeMessageDepsForTests,
+  _setMilestoneMergeMessageDepsForTests,
+  buildMilestoneMergeMessage,
+} from "../auto-worktree-merge-message.js";
+
+describe("buildMilestoneMergeMessage", () => {
+  beforeEach(() => {
+    _resetMilestoneMergeMessageDepsForTests();
+  });
+
+  afterEach(() => {
+    _resetMilestoneMergeMessageDepsForTests();
+  });
+
+  test("uses completed DB slices and tasks with display prefixes stripped", () => {
+    _setMilestoneMergeMessageDepsForTests({
+      isDbAvailable: () => true,
+      getMilestone: () => ({ id: "M002", title: "M002: Auth foundation" } as never),
+      getMilestoneSlices: () => [
+        { id: "S01", title: "S01: Login flow", status: "complete" },
+        { id: "S02", title: "S02: Later", status: "pending" },
+      ] as never,
+      getSliceTasks: (_milestoneId, sliceId) => sliceId === "S01"
+        ? [
+            { id: "T01", title: "T01: Add callback", status: "complete" },
+            { id: "T02", title: "T02: Pending", status: "pending" },
+          ] as never
+        : [] as never,
+    });
+
+    const result = buildMilestoneMergeMessage({
+      milestoneId: "M002",
+      milestoneBranch: "milestone/M002",
+      roadmapContent: "# M002: Roadmap title should not win when DB has title\n",
+    });
+
+    assert.equal(result.milestoneTitle, "Auth foundation");
+    assert.deepEqual(result.sliceSummaries, ["### S01\nLogin flow"]);
+    assert.equal(
+      result.commitMessage,
+      [
+        "feat: Auth foundation",
+        "",
+        "Completed slices:",
+        "- S01: Login flow",
+        "",
+        "Completed tasks:",
+        "- S01/T01: Add callback",
+        "",
+        "Milestone: M002 - Auth foundation",
+        "GSD-Milestone: M002",
+        "Branch: milestone/M002",
+      ].join("\n"),
+    );
+  });
+
+  test("falls back to checked roadmap slices and roadmap title when DB has no completed slices", () => {
+    _setMilestoneMergeMessageDepsForTests({
+      isDbAvailable: () => false,
+    });
+
+    const result = buildMilestoneMergeMessage({
+      milestoneId: "M007",
+      milestoneBranch: "milestone/M007",
+      roadmapContent: [
+        "# M007: Roadmap fallback",
+        "",
+        "- [x] **S01: First shipped slice**",
+        "- [ ] **S02: Not done**",
+        "- [x] **S03: Third shipped slice**",
+      ].join("\n"),
+    });
+
+    assert.equal(result.milestoneTitle, "Roadmap fallback");
+    assert.deepEqual(result.sliceSummaries, [
+      "### S01\nFirst shipped slice",
+      "### S03\nThird shipped slice",
+    ]);
+    assert.match(result.commitMessage, /^feat: Roadmap fallback\n\nCompleted slices:/);
+    assert.match(result.commitMessage, /- S01: First shipped slice/);
+    assert.match(result.commitMessage, /- S03: Third shipped slice/);
+    assert.doesNotMatch(result.commitMessage, /Completed tasks:/);
+  });
+
+  test("uses milestone id when no title or completed slice source exists", () => {
+    _setMilestoneMergeMessageDepsForTests({
+      isDbAvailable: () => false,
+    });
+
+    const result = buildMilestoneMergeMessage({
+      milestoneId: "M009",
+      milestoneBranch: "milestone/M009",
+      roadmapContent: "",
+    });
+
+    assert.deepEqual(result.sliceSummaries, []);
+    assert.equal(
+      result.commitMessage,
+      [
+        "feat: M009",
+        "",
+        "Milestone: M009",
+        "GSD-Milestone: M009",
+        "Branch: milestone/M009",
+      ].join("\n"),
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/auto-worktree-merge-pre-teardown.test.ts

@@ -0,0 +1,84 @@
+// gsd-pi — Regression tests for milestone merge pre-teardown safety.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetPreTeardownSafetyDepsForTests,
+  _setPreTeardownSafetyDepsForTests,
+  assertMilestoneWorktreeCleanBeforeTeardown,
+} from "../auto-worktree-merge-pre-teardown.js";
+import { GSDError } from "../errors.js";
+
+describe("assertMilestoneWorktreeCleanBeforeTeardown", () => {
+  const cwdBefore = process.cwd();
+
+  beforeEach(() => {
+    _resetPreTeardownSafetyDepsForTests();
+    process.chdir(cwdBefore);
+  });
+
+  afterEach(() => {
+    _resetPreTeardownSafetyDepsForTests();
+    process.chdir(cwdBefore);
+  });
+
+  test("throws and restores cwd when the milestone worktree is still dirty", () => {
+    const chdirCalls: string[] = [];
+    _setPreTeardownSafetyDepsForTests({
+      existsSync: () => true,
+      nativeGetCurrentBranch: () => "milestone/M002",
+      nativeWorkingTreeStatus: () => " M src/index.ts\n?? notes.txt",
+      chdir: (path) => {
+        chdirCalls.push(path);
+      },
+    });
+
+    assert.throws(
+      () => assertMilestoneWorktreeCleanBeforeTeardown({
+        milestoneBranch: "milestone/M002",
+        previousCwd: "/tmp/milestone-worktree",
+        worktreeCwd: "/tmp/milestone-worktree",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && /still has uncommitted changes/.test(err.message)
+        && /M src\/index\.ts/.test(err.message),
+    );
+    assert.deepEqual(chdirCalls, ["/tmp/milestone-worktree"]);
+  });
+
+  test("skips dirty work when the cwd is not the milestone branch", () => {
+    let dirtyChecks = 0;
+    _setPreTeardownSafetyDepsForTests({
+      existsSync: () => true,
+      nativeGetCurrentBranch: () => "main",
+      nativeWorkingTreeStatus: () => {
+        dirtyChecks += 1;
+        return " M unrelated.ts";
+      },
+    });
+
+    assert.doesNotThrow(() => assertMilestoneWorktreeCleanBeforeTeardown({
+      milestoneBranch: "milestone/M002",
+      previousCwd: "/tmp/main-worktree",
+      worktreeCwd: "/tmp/main-worktree",
+    }));
+    assert.equal(dirtyChecks, 0, "dirty state on another branch must not block cleanup");
+  });
+
+  test("fails open when dirty status cannot be read", () => {
+    _setPreTeardownSafetyDepsForTests({
+      existsSync: () => true,
+      nativeGetCurrentBranch: () => "milestone/M002",
+      nativeWorkingTreeStatus: () => {
+        throw new Error("status unavailable");
+      },
+    });
+
+    assert.doesNotThrow(() => assertMilestoneWorktreeCleanBeforeTeardown({
+      milestoneBranch: "milestone/M002",
+      previousCwd: "/tmp/milestone-worktree",
+      worktreeCwd: "/tmp/milestone-worktree",
+    }));
+  });
+});

package/src/resources/extensions/gsd/tests/auto-worktree-merge-stash.test.ts

@@ -0,0 +1,70 @@
+// gsd-pi — Pre-merge stash characterization tests.
+
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { createPreMergeStash } from "../auto-worktree-merge-stash.ts";
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  });
+}
+
+function createRepo(t: { after: (fn: () => void) => void }): string {
+  const root = mkdtempSync(join(tmpdir(), "gsd-merge-stash-test-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  git(root, ["init"]);
+  git(root, ["config", "user.email", "test@example.com"]);
+  git(root, ["config", "user.name", "Test User"]);
+  writeFileSync(join(root, "tracked.txt"), "base\n");
+  git(root, ["add", "."]);
+  git(root, ["commit", "-m", "init"]);
+  return root;
+}
+
+function status(root: string): string {
+  return git(root, ["status", "--porcelain"]);
+}
+
+test("pre-merge stash moves tracked and untracked local work out of the merge path", (t) => {
+  const root = createRepo(t);
+  writeFileSync(join(root, "tracked.txt"), "local edit\n");
+  writeFileSync(join(root, "untracked.txt"), "local untracked\n");
+
+  const stash = createPreMergeStash(root, "M001", false);
+  stash.stash();
+
+  assert.equal(status(root), "", "stash leaves the worktree clean for merge");
+  assert.ok(!existsSync(join(root, "untracked.txt")), "untracked files are included in the pre-merge stash");
+
+  stash.restoreForMergeFailure();
+
+  assert.equal(readFileSync(join(root, "tracked.txt"), "utf8"), "local edit\n");
+  assert.equal(readFileSync(join(root, "untracked.txt"), "utf8"), "local untracked\n");
+  assert.equal(git(root, ["stash", "list"]).trim(), "", "targeted restore consumes the pre-merge stash");
+});
+
+test("post-commit stash restore brings local work back after merge commit", (t) => {
+  const root = createRepo(t);
+  writeFileSync(join(root, "tracked.txt"), "local edit\n");
+  writeFileSync(join(root, "untracked.txt"), "local untracked\n");
+
+  const stash = createPreMergeStash(root, "M002", false);
+  stash.stash();
+  writeFileSync(join(root, "merged.txt"), "merged\n");
+  git(root, ["add", "merged.txt"]);
+  git(root, ["commit", "-m", "merge result"]);
+
+  stash.restoreAfterCommit();
+
+  assert.equal(readFileSync(join(root, "tracked.txt"), "utf8"), "local edit\n");
+  assert.equal(readFileSync(join(root, "untracked.txt"), "utf8"), "local untracked\n");
+  assert.equal(git(root, ["stash", "list"]).trim(), "", "post-commit restore consumes the pre-merge stash");
+});

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-shelter.test.ts

@@ -0,0 +1,52 @@
+// gsd-pi — Milestone directory shelter characterization tests.
+
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import {
+  createMilestoneDirectoryShelter,
+  _setRestoreEntryFnForTests,
+} from "../auto-worktree-milestone-shelter.ts";
+
+function createWorkspace(t: { after: (fn: () => void) => void }): string {
+  const root = mkdtempSync(join(tmpdir(), "gsd-shelter-test-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  mkdirSync(join(root, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(root, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(join(root, ".gsd", "milestones", "M001", "CONTEXT.md"), "# target\n");
+  writeFileSync(join(root, ".gsd", "milestones", "M002", "CONTEXT.md"), "# queued\n");
+  return root;
+}
+
+test("milestone directory shelter restores queued milestone dirs and cleans the shelter", (t) => {
+  const root = createWorkspace(t);
+
+  const shelter = createMilestoneDirectoryShelter(root, "M001", "Target milestone");
+
+  assert.ok(existsSync(join(root, ".gsd", "milestones", "M001", "CONTEXT.md")), "target milestone is not sheltered");
+  assert.ok(!existsSync(join(root, ".gsd", "milestones", "M002")), "queued milestone is moved out before stash");
+  assert.ok(existsSync(join(root, ".gsd", ".milestone-shelter", "M002", "CONTEXT.md")), "queued milestone is recoverable from shelter");
+
+  shelter.restore();
+  shelter.restore();
+
+  assert.equal(readFileSync(join(root, ".gsd", "milestones", "M002", "CONTEXT.md"), "utf8"), "# queued\n");
+  assert.ok(!existsSync(join(root, ".gsd", ".milestone-shelter")), "shelter is removed after successful restore");
+});
+
+test("milestone directory shelter retains recoverable copy when restore entry fails", (t) => {
+  const root = createWorkspace(t);
+  const restoreDefault = _setRestoreEntryFnForTests(() => {
+    throw new Error("forced restore failure");
+  });
+  t.after(restoreDefault);
+
+  const shelter = createMilestoneDirectoryShelter(root, "M001", "Target milestone");
+  shelter.restore();
+
+  assert.ok(!existsSync(join(root, ".gsd", "milestones", "M002", "CONTEXT.md")), "failed restore does not pretend queued files were restored");
+  assert.equal(readFileSync(join(root, ".gsd", ".milestone-shelter", "M002", "CONTEXT.md"), "utf8"), "# queued\n");
+});

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

@@ -7,15 +7,15 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { enterAutoWorktree } from "../auto-worktree-entry.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import {
-  getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
+  getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-  createAutoWorktree,
-  enterAutoWorktree,
-  mergeMilestoneToMain,
-  teardownAutoWorktree,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/auto-worktree-resource-version.test.ts

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  checkResourcesStale,
+  readResourceVersion,
+} from "../auto-worktree-resource-version.ts";
+
+function withAgentDir<T>(fn: (agentDir: string) => T): T {
+  const oldAgentDir = process.env.GSD_CODING_AGENT_DIR;
+  const agentDir = mkdtempSync(join(tmpdir(), "gsd-resource-version-"));
+  process.env.GSD_CODING_AGENT_DIR = agentDir;
+  try {
+    return fn(agentDir);
+  } finally {
+    if (oldAgentDir === undefined) {
+      delete process.env.GSD_CODING_AGENT_DIR;
+    } else {
+      process.env.GSD_CODING_AGENT_DIR = oldAgentDir;
+    }
+    rmSync(agentDir, { recursive: true, force: true });
+  }
+}
+
+test("readResourceVersion reads gsdVersion from managed-resources manifest", () => {
+  withAgentDir((agentDir) => {
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(
+      join(agentDir, "managed-resources.json"),
+      JSON.stringify({ gsdVersion: "1.2.3", syncedAt: "ignored" }),
+    );
+
+    assert.equal(readResourceVersion(), "1.2.3");
+  });
+});
+
+test("checkResourcesStale reports only when resource version changed", () => {
+  withAgentDir((agentDir) => {
+    writeFileSync(
+      join(agentDir, "managed-resources.json"),
+      JSON.stringify({ gsdVersion: "2.0.0" }),
+    );
+
+    assert.equal(checkResourcesStale(null), null);
+    assert.equal(checkResourcesStale("2.0.0"), null);
+    assert.equal(
+      checkResourcesStale("1.9.0"),
+      "GSD resources were updated since this session started. Restart gsd to load the new code.",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/auto-worktree-untracked-content.test.ts

@@ -8,7 +8,9 @@ import { existsSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "no
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { createAutoWorktree, teardownAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 import { classifyProject } from "../detection.ts";
 
 function runGit(args: string[], cwd: string): string {

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:");