@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.74e8dd1

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -22,23 +22,31 @@ import { tmpdir } from "node:os";
 
 import { loadSkills } from "@gsd/pi-coding-agent";
 import {
-  buildResearchSlicePrompt,
+  buildCompleteSlicePrompt,
   buildParallelResearchSlicesPrompt,
+  buildResearchSlicePrompt,
 } from "../auto-prompts.ts";
 
 const SKILL_NAME = "testskill";
+const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
 const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
+const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${COMPLETE_SLICE_SKILL_NAME}' })`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;
 
-function setupProjectWithSkill(): string {
+function setupProjectWithSkill(options: {
+  skillName?: string;
+  preferencesLines?: string[];
+} = {}): string {
+  const skillName = options.skillName ?? SKILL_NAME;
   const base = mkdtempSync(join(tmpdir(), "gsd-worker-skill-int-"));
   tmpDirs.push(base);
 
   // Milestone roadmap — buildResearchSlicePrompt inlines the roadmap excerpt.
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
-  mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+  const sliceOneDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceOneDir, "tasks"), { recursive: true });
   mkdirSync(join(milestoneDir, "slices", "S02"), { recursive: true });
   writeFileSync(
     join(milestoneDir, "M001-ROADMAP.md"),
@@ -55,27 +63,41 @@ function setupProjectWithSkill(): string {
     ].join("\n"),
     "utf-8",
   );
+  writeFileSync(
+    join(sliceOneDir, "S01-PLAN.md"),
+    [
+      "# S01: Alpha",
+      "",
+      "**Goal:** Verify worker x skill prompt plumbing.",
+      "**Demo:** Rendered prompts include the skill activation block.",
+      "",
+      "## Tasks",
+      "- [x] **T01: Task** `est:10m`",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
 
   // Project preferences — buildSkillActivationBlock picks these up via
   // loadEffectiveGSDPreferences(), which reads from `${cwd}/.gsd/PREFERENCES.md`.
   writeFileSync(
     join(base, ".gsd", "PREFERENCES.md"),
-    ["---", `always_use_skills:`, `  - ${SKILL_NAME}`, "---", ""].join("\n"),
+    ["---", ...(options.preferencesLines ?? [`always_use_skills:`, `  - ${skillName}`]), "---", ""].join("\n"),
     "utf-8",
   );
 
   // Project-scoped skill — resolveSkillReference scans `${cwd}/.agents/skills/`.
-  const skillDir = join(base, ".agents", "skills", SKILL_NAME);
+  const skillDir = join(base, ".agents", "skills", skillName);
   mkdirSync(skillDir, { recursive: true });
   writeFileSync(
     join(skillDir, "SKILL.md"),
     [
       "---",
-      `name: ${SKILL_NAME}`,
+      `name: ${skillName}`,
       `description: Integration-test skill for worker × skill prompt plumbing.`,
       "---",
       "",
-      `# ${SKILL_NAME}`,
+      `# ${skillName}`,
       "",
       "Test skill body.",
     ].join("\n"),
@@ -122,6 +144,31 @@ test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from
   );
 });
 
+test("complete-slice prompt includes <skill_activation> from unit-specific skill_rules", async () => {
+  const base = setupProjectWithSkill({
+    skillName: COMPLETE_SLICE_SKILL_NAME,
+    preferencesLines: [
+      "skill_rules:",
+      "  - when: complete-slice",
+      "    use:",
+      `      - ${COMPLETE_SLICE_SKILL_NAME}`,
+    ],
+  });
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildCompleteSlicePrompt("M001", "Test Milestone", "S01", "Alpha", base, "minimal");
+
+  assert.ok(
+    prompt.includes("<skill_activation>"),
+    "complete-slice prompt should contain a <skill_activation> block",
+  );
+  assert.ok(
+    prompt.includes(COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING),
+    `complete-slice prompt should reference the skill-rule skill '${COMPLETE_SLICE_SKILL_NAME}'`,
+  );
+});
+
 test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skill_activation> into each embedded per-slice section", async () => {
   const base = setupProjectWithSkill();
   savedCwd = process.cwd();

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -6,7 +6,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, getSliceTasks, getTask, getGateResults, updateTaskStatus } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getSliceTasks, getTask, getGateResults, updateTaskStatus } from '../gsd-db.ts';
 import { handlePlanSlice } from '../tools/plan-slice.ts';
 import { parsePlan } from '../parsers-legacy.ts';
 import { parseTaskPlanFile } from '../files.ts';
@@ -265,6 +265,44 @@ test('handlePlanSlice renders plan artifacts under worktree-local .gsd while usi
   }
 });
 
+test('handlePlanSlice preserves completed task closeout state when replanning the same task', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    insertTask({
+      id: 'T01',
+      sliceId: 'S02',
+      milestoneId: 'M001',
+      title: 'Completed implementation',
+      status: 'complete',
+      oneLiner: 'Completed implementation',
+      narrative: 'Already finished.',
+      verificationResult: 'passed',
+      fullSummaryMd: '# T01 Summary\n\nAlready finished.\n',
+    });
+
+    const before = getTask('M001', 'S02', 'T01');
+    assert.equal(before?.status, 'complete');
+    assert.ok(before?.completed_at, 'completed task should have a completion timestamp');
+    assert.equal(before?.full_summary_md, '# T01 Summary\n\nAlready finished.\n');
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const after = getTask('M001', 'S02', 'T01');
+    assert.equal(after?.status, 'complete', 'replanning must not reset completed task status to pending');
+    assert.equal(after?.completed_at, before?.completed_at, 'replanning must not clear completed_at');
+    assert.equal(after?.full_summary_md, before?.full_summary_md, 'replanning must not clear task summary content');
+    assert.equal(after?.verification_result, 'passed', 'replanning must not clear closeout verification');
+    assert.equal(after?.description, 'Implement the slice planning handler.', 'planning fields should still refresh');
+    assert.equal(getTask('M001', 'S02', 'T02')?.status, 'pending', 'new tasks are still inserted as pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice advances DB-derived state out of planning immediately', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -32,6 +32,16 @@ test("run-uat prompt branches on dynamic UAT mode and supports runtime evidence"
   assert.doesNotMatch(prompt, /uatType:\s*artifact-driven/);
 });
 
+test("run-uat prompt lists canonical gsd_uat_exec intent values", () => {
+  const prompt = readPrompt("run-uat");
+  assert.match(prompt, /`uat-artifact-check`/);
+  assert.match(prompt, /`uat-runtime-check`/);
+  assert.match(prompt, /`uat-browser-check`/);
+  assert.match(prompt, /`uat-service-start`/);
+  assert.match(prompt, /`uat-log-inspection`/);
+  assert.match(prompt, /do not use `artifact`, `runtime`, or `human-follow-up` as `intent`/i);
+});
+
 test("workflow-start prompt defaults to autonomy instead of per-phase confirmation", () => {
   const prompt = readPrompt("workflow-start");
   assert.match(prompt, /Keep moving by default/i);

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -17,7 +17,10 @@ import {
   shouldDeferTransientErrorToCoreRetry,
   suppressTerminalDeletedWorktreeMessageEnd,
 } from "../bootstrap/agent-end-recovery.ts";
-import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
+import {
+  _buildCancelledUnitStopReason,
+  _classifyZeroToolProviderMessageForTest,
+} from "../auto/phases.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -53,6 +56,20 @@ test("classifyError treats usage-limit phrasing as transient rate-limit (#4373)"
   assert.equal(result.kind, "rate-limit");
 });
 
+test("zero-tool provider classifier treats Claude session-limit wording as transient rate-limit (#371)", () => {
+  const result = _classifyZeroToolProviderMessageForTest("Claude Code session limit reached. Limit resets at 5 PM.");
+  assert.ok(result, "session-limit wording should be recognized");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+});
+
+test("zero-tool provider classifier treats weekly limit wording as transient rate-limit (#371)", () => {
+  const result = _classifyZeroToolProviderMessageForTest("You've reached your weekly limit. Try again later.");
+  assert.ok(result, "weekly limit wording should be recognized");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+});
+
 test("classifyError treats extra-usage phrasing as transient rate-limit (#4397)", () => {
   const result = classifyError("You are out of extra usage. Please wait before retrying.");
   assert.ok(isTransient(result));

package/src/resources/extensions/gsd/tests/reactive-executor.test.ts

@@ -17,6 +17,10 @@ import { validatePreferences } from "../preferences-validation.ts";
 import type { ReactiveExecutionState } from "../types.ts";
 import { parseUnitId } from "../unit-id.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
+import {
+  _getPlannedKeyFilesForTest,
+  _parseReactiveBatchTaskIdsForTest,
+} from "../auto-post-unit.ts";
 
 // ─── Preference Validation ────────────────────────────────────────────────
 
@@ -71,6 +75,38 @@ test("reactive_execution validation warns on unknown keys", () => {
   assert.ok(result.warnings.some((w) => w.includes("unknown_thing")));
 });
 
+test("reactive batch unit ids are parsed and deduped for commit context", () => {
+  assert.deepEqual(
+    _parseReactiveBatchTaskIdsForTest("M001/S01/reactive+T01,t02,T01"),
+    ["T01", "T02"],
+  );
+  assert.deepEqual(_parseReactiveBatchTaskIdsForTest("M001/S01/T01"), []);
+});
+
+test("reactive commit context key files include planned output, files, and key_files once", () => {
+  const result = _getPlannedKeyFilesForTest([
+    {
+      expected_output: ["src/new.ts", "src/shared.ts"],
+      files: ["src/input.ts", "src/shared.ts"],
+      key_files: ["src/key.ts"],
+    },
+    {
+      expected_output: ["src/new.ts"],
+      files: ["src/other.ts"],
+      key_files: ["src/key.ts", "src/final.ts"],
+    },
+  ]);
+
+  assert.deepEqual(result, [
+    "src/new.ts",
+    "src/shared.ts",
+    "src/input.ts",
+    "src/key.ts",
+    "src/other.ts",
+    "src/final.ts",
+  ]);
+});
+
 // ─── Dispatch Rule Matching Logic ─────────────────────────────────────────
 
 test("reactive dispatch requires enabled config and multiple ready tasks", async () => {

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -10,6 +10,7 @@ import {
   resetWriteGateState,
   shouldBlockContextArtifactSave,
 } from "../bootstrap/write-gate.ts";
+import { classifyCommand } from "../safety/destructive-guard.ts";
 import { toRoundResultResponse } from "../../remote-questions/manager.ts";
 
 function makeTempDir(prefix: string): string {
@@ -35,6 +36,40 @@ async function armDepthGate(
   }
 }
 
+test("destructive guard classifies infrastructure mutation commands", () => {
+  assert.deepEqual(classifyCommand("terraform destroy -auto-approve").labels, ["IaC apply/destroy"]);
+  assert.deepEqual(classifyCommand("terragrunt apply").labels, ["IaC apply/destroy"]);
+  assert.deepEqual(classifyCommand("aws s3 delete-bucket --bucket example").labels, ["AWS mutation"]);
+  assert.deepEqual(classifyCommand("kubectl delete namespace prod").labels, ["kubectl mutation"]);
+});
+
+test("register-hooks hard-blocks destructive bash commands outside auto-mode", async () => {
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  let block: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolCallId: "call-1",
+      toolName: "bash",
+      input: { command: "terraform apply -auto-approve" },
+    });
+    if (result?.block) block = result;
+  }
+
+  assert.equal(block?.block, true);
+  assert.match(block?.reason ?? "", /HARD BLOCK: destructive Bash command requires explicit human confirmation/);
+  assert.match(block?.reason ?? "", /IaC apply\/destroy/);
+});
+
 test("register-hooks unlocks milestone depth verification from question id without guided-flow state (#4047)", async (t) => {
   const dir = makeTempDir("manual");
   const originalCwd = process.cwd();

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -51,7 +51,7 @@ test("discuss workflow scopes tools for the queued turn and restores the full to
     // discuss allowlist: gsd_summary_save and gsd_plan_milestone (the latter
     // is needed for the discuss.md output phase — see DISCUSS_TOOLS_ALLOWLIST).
     // gsd_task_complete and the broad shell_exec tool are scoped out.
-    assert.deepEqual(sentTools, ["gsd_summary_save", "gsd_plan_milestone", "ToolSearch"]);
+    assert.deepEqual(sentTools, ["gsd_plan_milestone", "gsd_summary_save", "ToolSearch"]);
     assert.deepEqual(activeTools, originalTools);
     assert.equal(triggerTurn, true);
   } finally {

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { loadSkills } from "@gsd/pi-coding-agent";
 import {
+  buildCompleteSlicePrompt,
   buildPlanMilestonePrompt,
   buildResearchMilestonePrompt,
   buildSkillActivationBlock,
@@ -143,6 +144,29 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
   }
 });
 
+test("buildSkillActivationBlock matches skill_rules against exact unit type context", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "complete-slice-policies", "Use for complete-slice closeout policy checks.");
+    writeSkill(base, "slice-broad", "Use for broad slice work.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {
+      unitType: "complete-slice",
+    }, {
+      skill_rules: [
+        { when: "complete-slice", use: ["complete-slice-policies"] },
+        { when: "slice", use: ["slice-broad"] },
+      ],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'complete-slice-policies' \}\)/);
+    assert.doesNotMatch(result, /slice-broad/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("buildSkillActivationBlock honors avoid_skills against always_use_skills", () => {
   const base = makeTempBase();
   try {
@@ -328,6 +352,37 @@ test("milestone prompt builders propagate always_use_skills through buildSkillAc
   }
 });
 
+test("complete-slice prompt propagates always_use_skills through buildSkillActivationBlock", async () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeProjectPreferences(base, "always_use_skills:\n  - write-docs\n");
+    loadOnlyTestSkills(base);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    const sliceDir = join(milestoneDir, "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(milestoneDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Test",
+        "",
+        "## Slices",
+        "",
+        "- [ ] **S01: Slice** `risk:low` `depends:[]`",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Slice\n\n## Tasks\n\n- [x] **T01: Done**\n");
+
+    const prompt = await buildCompleteSlicePrompt("M001", "Test", "S01", "Slice", base);
+
+    assert.match(prompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("skill manifest strict warnings require GSD_SKILL_MANIFEST_STRICT=1", (t) => {
   const previousStrict = process.env.GSD_SKILL_MANIFEST_STRICT;
   const previousStderr = setStderrLoggingEnabled(false);

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

@@ -148,6 +148,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   const freshStartSectionIdx = startAutoBody.indexOf("// ── Fresh start path — delegated to auto-start.ts ──");
   const resumeBody = startAutoBody.slice(resumeSectionIdx, freshStartSectionIdx);
   const resumeDbOpenIdx = resumeBody.indexOf("await openProjectDbIfPresent(base);");
+  const resumeMergeReconcileIdx = resumeBody.indexOf("reconcileMergedMilestonesFromJournal(base);");
   const resumeRegisterIdx = resumeBody.indexOf("registerAutoWorkerForSession(s, base);");
   const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
   const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
@@ -164,6 +165,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   assert.ok(resumeSectionIdx > -1, "startAuto should have resume milestone entry flow");
   assert.ok(freshStartSectionIdx > resumeSectionIdx, "resume assertions should be scoped before fresh start");
   assert.ok(resumeDbOpenIdx > -1, "resume should open DB before milestone entry");
+  assert.ok(resumeMergeReconcileIdx > -1, "resume should reconcile merged milestones before deriving dispatch state");
   assert.ok(resumeRegisterIdx > -1, "resume should register worker before milestone entry");
   assert.ok(resumeEnterMilestoneIdx > -1, "resume should enter milestones through lifecycle");
   assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
@@ -179,8 +181,10 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
     "bootstrap must open DB and register worker before first enterMilestone",
   );
   assert.ok(
-    resumeDbOpenIdx < resumeRegisterIdx && resumeRegisterIdx < resumeEnterMilestoneIdx,
-    "resume must open DB and register worker before first enterMilestone",
+    resumeDbOpenIdx < resumeMergeReconcileIdx &&
+      resumeMergeReconcileIdx < resumeRegisterIdx &&
+      resumeRegisterIdx < resumeEnterMilestoneIdx,
+    "resume must open DB, reconcile merged milestones, and register worker before first enterMilestone",
   );
 });
 

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -906,6 +906,51 @@ test("ADR-017 (#5704): registered milestone (DB row present) → no drift", asyn
 
 // ─── #5705: roadmap-divergence drift ─────────────────────────────────────────
 
+test("ADR-017 (#391): roadmap-divergence skips slices before task planning completes", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-unplanned-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
+  mkdirSync(milestoneDir, { recursive: true });
+  const originalRoadmap = [
+    "# M001: Test",
+    "",
+    "**Vision:** Verify transient milestone planning state",
+    "",
+    "## Slices",
+    "",
+    "- [ ] **S01: Foundation** `risk:medium` `depends:[]`",
+    "- [ ] **S02: Feature** `risk:medium` `depends:[S01]`",
+    "",
+  ].join("\n");
+  writeFileSync(roadmapPath, originalRoadmap);
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Feature", status: "pending", risk: "medium", depends: [], demo: "", sequence: 2 });
+
+  assert.equal(getSliceTasks("M001", "S01").length, 0, "pre: S01 has not been planned");
+  assert.equal(getSliceTasks("M001", "S02").length, 0, "pre: S02 has not been planned");
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(
+    result.repaired.some((d) => d.kind === "roadmap-divergence"),
+    false,
+    "unplanned slices should not trigger roadmap-divergence repair",
+  );
+  assert.equal(readFileSync(roadmapPath, "utf-8"), originalRoadmap);
+  assert.deepEqual(getSlice("M001", "S02")?.depends, [], "DB remains unchanged");
+});
+
 test("ADR-017 (#5705): roadmap-divergence re-renders projection without syncing depends into DB", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-"));
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
@@ -936,6 +981,8 @@ test("ADR-017 (#5705): roadmap-divergence re-renders projection without syncing
   // Seed DB with S02 depending on []  — diverges from ROADMAP.md
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
   insertSlice({ id: "S02", milestoneId: "M001", title: "Feature", status: "pending", risk: "medium", depends: [], demo: "", sequence: 2 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Plan S02", status: "pending" });
 
   assert.deepEqual(getSlice("M001", "S02")?.depends, [], "pre: DB has S02.depends = []");
 
@@ -987,6 +1034,7 @@ test("ADR-017 (#5705): ROADMAP-only slice is removed from projection and not ins
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   // Only insert S01 — S02 is intentionally absent from the DB.
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
 
   assert.equal(getSlice("M001", "S02"), null, "pre: S02 has no DB row");
 
@@ -1035,6 +1083,8 @@ test("ADR-017 (#5705): ROADMAP sequence drift re-renders from DB order without m
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
   insertSlice({ id: "S02", milestoneId: "M001", title: "Feature", status: "pending", risk: "medium", depends: [], demo: "", sequence: 2 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Plan S02", status: "pending" });
 
   const result = await reconcileBeforeDispatch(base, {
     invalidateStateCache: () => {},
@@ -1078,6 +1128,7 @@ test("ADR-017 (#5705): ROADMAP checkbox drift re-renders from DB status without
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
 
   const result = await reconcileBeforeDispatch(base, {
     invalidateStateCache: () => {},
@@ -1119,6 +1170,7 @@ test("ADR-017 (#5705): in-sync ROADMAP and DB → no roadmap-divergence drift",
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "low", depends: [], demo: "", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Plan S01", status: "pending" });
 
   const result = await reconcileBeforeDispatch(base, {
     invalidateStateCache: () => {},