@opengsd/gsd-pi 1.0.2-dev.e9a1b49 → 1.0.2-dev.fb7ddf1

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

@@ -2,9 +2,10 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { execFileSync } from "node:child_process";
 import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "../repository-registry.ts";
 
 test("repository registry includes implicit project root and declared child repos", (t) => {
@@ -99,3 +100,31 @@ test("defaultRepositoryTargets returns [project] for a parent-mode registry", (t
 
   assert.deepEqual(defaultRepositoryTargets(registry), ["project"]);
 });
+
+test("repository registry keeps project root anchored to .gsd project in monorepo subdirectory", (t) => {
+  const monorepo = mkdtempSync(join(tmpdir(), "gsd-repo-registry-mono-"));
+  t.after(() => rmSync(monorepo, { recursive: true, force: true }));
+  execFileSync("git", ["init"], { cwd: monorepo, stdio: "ignore" });
+
+  const subproject = join(monorepo, "fieldkit-tools");
+  mkdirSync(join(subproject, ".gsd"), { recursive: true });
+  writeFileSync(join(subproject, ".gsd", "PREFERENCES.md"), "---\nversion: 1\n---\n");
+
+  const registry = createRepositoryRegistryFromPreferences(subproject, undefined);
+
+  assert.equal(registry.projectRoot, subproject);
+  assert.equal(registry.byId.get("project")?.root, subproject);
+});
+
+test("repository registry uses external-state worktree checkout as project root", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-external-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  const worktree = join(base, ".gsd", "projects", "abc123", "worktrees", "M001");
+  mkdirSync(worktree, { recursive: true });
+  execFileSync("git", ["init"], { cwd: worktree, stdio: "ignore" });
+
+  const registry = createRepositoryRegistryFromPreferences(worktree, undefined);
+
+  assert.equal(registry.projectRoot, worktree);
+  assert.equal(registry.byId.get("project")?.root, worktree);
+});

package/src/resources/extensions/gsd/tests/show-config-command.test.ts

@@ -7,6 +7,7 @@ import assert from "node:assert/strict";
 
 import { GSDConfigOverlay, formatConfigText } from "../config-overlay.ts";
 import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const theme = {
   bold: (s: string) => s,
@@ -24,6 +25,9 @@ test("GSDConfigOverlay renders and responds to input", () => {
 
   const lines = overlay.render(60);
   assert.ok(lines.some((line) => line.includes("GSD Configuration")));
+  assertFullOuterBorder(lines, 60);
+  assert.match(lines[0] ?? "", /^╭─ GSD Configuration /);
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
 
   overlay.handleInput("j");
   assert.equal(renderRequests, 1);

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

@@ -0,0 +1,111 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  appendDiscoveredSkillsFallback,
+  clearSkillSnapshot,
+  detectNewSkills,
+  refreshCatalogForNewSkills,
+  snapshotSkills,
+} from "../skill-discovery.js";
+
+function makeTempHome(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-skill-discovery-"));
+}
+
+async function withTempSkillHome<T>(fn: (home: string) => T | Promise<T>): Promise<T> {
+  const previousHome = process.env.HOME;
+  const previousGsdHome = process.env.GSD_HOME;
+  const home = makeTempHome();
+  process.env.HOME = home;
+  process.env.GSD_HOME = join(home, ".gsd");
+  try {
+    return await fn(home);
+  } finally {
+    clearSkillSnapshot();
+    if (previousHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = previousHome;
+    }
+    if (previousGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = previousGsdHome;
+    }
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+function writeDiskSkill(root: string, name: string, description = `Use for ${name}.`): void {
+  const dir = join(root, name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "SKILL.md"), `---\nname: ${name}\ndescription: ${description}\n---\n\n# ${name}\n`);
+}
+
+test("detectNewSkills detects skills added on disk after the baseline snapshot", async () => {
+  await withTempSkillHome((home) => {
+    const skillsRoot = join(home, ".agents", "skills");
+    writeDiskSkill(skillsRoot, "existing-skill");
+    snapshotSkills();
+
+    writeDiskSkill(skillsRoot, "new-disk-skill", "New disk skill.");
+    const detected = detectNewSkills();
+
+    assert.deepEqual(detected.map(skill => skill.name), ["new-disk-skill"]);
+    assert.equal(detected[0].description, "New disk skill.");
+    assert.equal(detected[0].location, join(skillsRoot, "new-disk-skill", "SKILL.md"));
+  });
+});
+
+test("refreshCatalogForNewSkills retries discovery after reload failure", async () => {
+  await withTempSkillHome(async (home) => {
+    const skillsRoot = join(home, ".agents", "skills");
+    snapshotSkills();
+    writeDiskSkill(skillsRoot, "reload-retry-skill");
+
+    const messages: Array<{ message: string; level: "info" | "warning" }> = [];
+    const failed = await refreshCatalogForNewSkills({
+      reload: async () => { throw new Error("reload failed"); },
+      notify: (message, level) => messages.push({ message, level }),
+    });
+
+    assert.deepEqual(failed.map(skill => skill.name), ["reload-retry-skill"]);
+    assert.deepEqual(detectNewSkills().map(skill => skill.name), ["reload-retry-skill"]);
+    assert.equal(messages[0]?.level, "warning");
+
+    const loaded = await refreshCatalogForNewSkills({
+      reload: async () => {},
+      notify: (message, level) => messages.push({ message, level }),
+    });
+
+    assert.deepEqual(loaded.map(skill => skill.name), ["reload-retry-skill"]);
+    assert.deepEqual(detectNewSkills(), []);
+    assert.ok(messages.some(({ level, message }) => level === "info" && message.includes("reload-retry-skill")));
+  });
+});
+
+test("appendDiscoveredSkillsFallback exposes newly detected skills missing from the prompt", () => {
+  const prompt = appendDiscoveredSkillsFallback("base system prompt", [{
+    name: "fallback-skill",
+    description: "Use when reload fails & skill is needed.",
+    location: "/tmp/fallback-skill/SKILL.md",
+  }]);
+
+  assert.match(prompt, /<newly_discovered_skills>/);
+  assert.match(prompt, /fallback-skill/);
+  assert.match(prompt, /Use when reload fails &amp; skill is needed\./);
+  assert.match(prompt, /\/tmp\/fallback-skill\/SKILL.md/);
+});
+
+test("appendDiscoveredSkillsFallback does not duplicate skills already in the prompt", () => {
+  const prompt = "base system prompt\n/tmp/already-loaded/SKILL.md";
+
+  assert.equal(appendDiscoveredSkillsFallback(prompt, [{
+    name: "already-loaded",
+    description: "Already present.",
+    location: "/tmp/already-loaded/SKILL.md",
+  }]), prompt);
+});

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

@@ -0,0 +1,67 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyUnitSkillVisibility,
+  effectiveSkillNamesForUnit,
+  resolveVisibleSkillNames,
+  unitHasSkillManifest,
+} from "../skill-scope.ts";
+
+test("resolveVisibleSkillNames: none policy suppresses catalog", () => {
+  assert.deepEqual(resolveVisibleSkillNames("workflow-preferences"), []);
+  assert.equal(unitHasSkillManifest("workflow-preferences"), true);
+});
+
+test("resolveVisibleSkillNames: wildcard units use full catalog", () => {
+  assert.equal(resolveVisibleSkillNames("execute-task"), undefined);
+  assert.equal(unitHasSkillManifest("execute-task"), false);
+});
+
+test("unitHasSkillManifest: manifest unit types return true", () => {
+  assert.equal(unitHasSkillManifest("research-milestone"), true);
+  assert.equal(unitHasSkillManifest("plan-slice"), true);
+});
+
+test("unitHasSkillManifest: wildcard unit types return false", () => {
+  assert.equal(unitHasSkillManifest("execute-task"), false);
+  assert.equal(unitHasSkillManifest(undefined), false);
+  assert.equal(unitHasSkillManifest("unknown-unit"), false);
+});
+
+test("applyUnitSkillVisibility: sets manifest names for scoped units", () => {
+  let visible: string[] | undefined;
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      visible = names;
+    },
+  }, "research-milestone");
+
+  assert.ok(Array.isArray(visible));
+  assert.ok(visible!.includes("write-docs"));
+  assert.ok(visible!.length < 15);
+});
+
+test("applyUnitSkillVisibility: restores full catalog for wildcard units", () => {
+  let visible: string[] | undefined = ["stale"];
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      visible = names;
+    },
+  }, "execute-task");
+
+  assert.equal(visible, undefined);
+});
+
+test("effectiveSkillNamesForUnit: filters installed names by manifest", () => {
+  const installed = ["write-docs", "review", "frontend-design", "tdd"];
+  const scoped = effectiveSkillNamesForUnit("research-milestone", installed);
+  assert.ok(scoped.includes("write-docs"));
+  assert.ok(!scoped.includes("review"));
+  assert.ok(scoped.length < installed.length);
+});
+
+test("effectiveSkillNamesForUnit: pass-through for wildcard units", () => {
+  const installed = ["write-docs", "review"];
+  assert.deepEqual(effectiveSkillNamesForUnit("execute-task", installed), installed);
+});

package/src/resources/extensions/gsd/tests/skills.test.ts

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { Skill } from "@gsd/pi-coding-agent";
+import {
+  detectNewlyInstalledSkills,
+  getInstalledSkillNames,
+  getInstalledSkills,
+  normalizeSkillName,
+  resolveInstalledSkill,
+  snapshotInstalledSkillNames,
+} from "../skills.js";
+
+function makeSkill(name: string, filePath = `/tmp/${name}/SKILL.md`): Skill {
+  return {
+    name,
+    description: `Use for ${name}.`,
+    filePath,
+    baseDir: `/tmp/${name}`,
+    source: "user",
+    sourceInfo: {
+      path: filePath,
+      source: "local",
+      scope: "user",
+      origin: "top-level",
+      baseDir: `/tmp/${name}`,
+    },
+    disableModelInvocation: false,
+  };
+}
+
+test("normalizeSkillName lowercases and trims", () => {
+  assert.equal(normalizeSkillName("  React-Best  "), "react-best");
+});
+
+test("getInstalledSkills returns explicit override", () => {
+  const skills = [makeSkill("alpha"), makeSkill("beta")];
+  assert.deepEqual(getInstalledSkills(skills).map((s) => s.name), ["alpha", "beta"]);
+});
+
+test("snapshotInstalledSkillNames and detectNewlyInstalledSkills diff normalized names", () => {
+  const baseline = snapshotInstalledSkillNames([makeSkill("alpha")]);
+  const added = detectNewlyInstalledSkills(baseline, [makeSkill("alpha"), makeSkill("Beta")]);
+  assert.deepEqual(added, ["beta"]);
+});
+
+test("getInstalledSkillNames maps skill names", () => {
+  assert.deepEqual(getInstalledSkillNames([makeSkill("tdd")]), ["tdd"]);
+});
+
+test("resolveInstalledSkill matches installed catalog by name", () => {
+  const skills = [makeSkill("react", "/home/user/.gsd/agent/skills/react/SKILL.md")];
+  const result = resolveInstalledSkill("react", "/project", skills);
+  assert.equal(result.skill?.name, "react");
+  assert.equal(result.resolvedPath, "/home/user/.gsd/agent/skills/react/SKILL.md");
+});

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

@@ -15,6 +15,13 @@ function readGsdFile(relativePath: string): string {
   return readFileSync(resolve(gsdDir, relativePath), "utf-8");
 }
 
+function firstIndexOfAny(source: string, needles: string[]): number {
+  const indexes = needles
+    .map((needle) => source.indexOf(needle))
+    .filter((index) => index > -1);
+  return indexes.length > 0 ? Math.min(...indexes) : -1;
+}
+
 test("command entrypoints use startAutoDetached instead of awaiting startAuto (#3733)", () => {
   const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
   const workflowHandlerSrc = readGsdFile("commands/handlers/workflow.ts");
@@ -145,7 +152,11 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
   const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
   const bootstrapRegisterIdx = bootstrapBody.indexOf("registerAutoWorkerForSession(base);");
-  const enterMilestoneIdx = bootstrapBody.indexOf("buildLifecycle().enterMilestone");
+  const enterMilestoneIdx = firstIndexOfAny(bootstrapBody, [
+    "buildLifecycle().enterMilestone",
+    "lifecycle.enterMilestone",
+    "lifecycle.adoptStrandedMilestone",
+  ]);
 
   assert.ok(startAutoIdx > -1, "startAuto should exist");
   assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
@@ -158,7 +169,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
   assert.ok(dbOpenIdx > -1, "bootstrap should open the project DB");
   assert.ok(bootstrapRegisterIdx > -1, "bootstrap should register worker after DB open");
-  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter milestones through lifecycle");
+  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter or adopt milestones through lifecycle");
   assert.ok(
     preBootstrapRegisterIdx < bootstrapCallIdx,
     "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",

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

@@ -17,6 +17,8 @@ import { randomUUID } from "node:crypto";
 import {
   openDatabase,
   closeDatabase,
+  _getAdapter,
+  insertArtifact,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -229,6 +231,175 @@ test("ADR-017 (#5700): classifyFailure recognizes ReconciliationFailedError", ()
   assert.match(result.remediation, /persistent or repair-failed drift kinds/);
 });
 
+test("ADR-017: terminal drift blockers return blockers instead of repair exceptions", async () => {
+  const record: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const handler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => [record],
+    blocker: () => "manual drift review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [handler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["manual drift review required"]);
+  assert.equal(result.repaired.length, 0);
+});
+
+test("ADR-017: terminal blockers return a state snapshot refreshed after co-occurring repairs", async () => {
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  let repaired = false;
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: (state) => (state.nextAction === "before repair" ? [repairDrift] : []),
+    repair: () => {
+      repaired = true;
+    },
+  };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: (state) => (state.nextAction === "before repair" ? [terminalDrift] : []),
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () =>
+      makeState({ nextAction: repaired ? "after repair" : "before repair" }),
+    registry: [repairHandler, terminalHandler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.stateSnapshot.nextAction, "after repair");
+  assert.equal(result.repaired.length, 1);
+  assert.deepEqual(result.blockers, ["manual completed-milestone review required"]);
+});
+
+test("ADR-017: terminal drift blockers take precedence over co-occurring repair failures", async () => {
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: () => [terminalDrift],
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => [repairDrift],
+    repair: () => {
+      throw new Error("simulated repair failure");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [repairHandler, terminalHandler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["manual completed-milestone review required"]);
+});
+
+test("ADR-017: terminal drift found after repair cap returns blockers", async () => {
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  let repairCount = 0;
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => (repairCount < 2 ? [repairDrift] : []),
+    repair: () => {
+      repairCount++;
+    },
+  };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: () => (repairCount >= 2 ? [terminalDrift] : []),
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [repairHandler, terminalHandler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.repaired.length, 2);
+  assert.deepEqual(result.blockers, ["manual completed-milestone review required"]);
+});
+
+test("ADR-017: final persistent drift mixed with blockers still fails closed", async () => {
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  let repairCount = 0;
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => [repairDrift],
+    repair: () => {
+      repairCount++;
+    },
+  };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: () => (repairCount >= 2 ? [terminalDrift] : []),
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  await assert.rejects(
+    () =>
+      reconcileBeforeDispatch("/project", {
+        invalidateStateCache: () => {},
+        deriveState: async () => makeState(),
+        registry: [repairHandler, terminalHandler],
+      }),
+    (err: unknown) => {
+      assert.ok(err instanceof ReconciliationFailedError);
+      assert.deepEqual(err.persistentDrift.map((d) => d.kind).sort(), [
+        "completed-milestone-reopened",
+        "stale-sketch-flag",
+      ]);
+      return true;
+    },
+  );
+});
+
 // ─── #5701: merge-state drift ────────────────────────────────────────────────
 
 function makeGitBase(): string {
@@ -1052,6 +1223,138 @@ test("ADR-017 (#5706): repair is idempotent — re-running preserves the timesta
   assert.equal(getSlice("M001", "S01")?.completed_at, tsAfterFirst, "timestamp unchanged");
 });
 
+test("ADR-017: artifact/DB status divergence fails closed instead of importing completion artifacts", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-artifact-db-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"),
+    "# S01 Summary\n\nAlready done on disk.\n",
+  );
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.match(result.blockers.join("\n"), /Artifact\/DB status drift/);
+  assert.equal(getSlice("M001", "S01")?.status, "pending", "DB status remains authoritative");
+});
+
+test("ADR-017: meaningful disk-only slice drift blocker includes repair guidance", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-disk-slice-guidance-"));
+  const diskOnlySliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S99");
+  t.after(() => cleanup(base));
+
+  mkdirSync(diskOnlySliceDir, { recursive: true });
+  writeFileSync(join(diskOnlySliceDir, "S99-PLAN.md"), "# Disk-only plan\n\nWork to review.\n");
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Known Slice", status: "pending" });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  const message = result.blockers.join("\n");
+  assert.match(message, /Slice ID drift in M001/);
+  assert.match(message, /Review .*S99/);
+  assert.match(message, /move or delete/);
+  assert.match(message, /\.gsd\/quarantine\/milestones\/M001\/slices\/S99-manual-review/);
+  assert.match(message, /copy or merge/);
+  assert.match(message, /\/gsd doctor M001/);
+  assert.match(message, /\/gsd next or \/gsd auto/);
+});
+
+test("ADR-017: orphan task completion artifact fails closed", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orphan-task-artifact-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T99"), { recursive: true });
+  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", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T99", "T99-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: "T99",
+    full_content: "# T99 Summary\n\nStale artifact after replan.\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.match(result.blockers.join("\n"), /Artifact\/DB status drift/);
+});
+
+test("ADR-017: completed milestone dispatch history blocks accidental re-planning", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-completed-reopened-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+
+  const adapter = _getAdapter();
+  assert.ok(adapter);
+  adapter.prepare(
+    `INSERT OR REPLACE INTO workers
+      (worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath)
+     VALUES ('w1', 'local', 1, '2026-05-30T00:00:00.000Z', 'test', '2026-05-30T00:00:00.000Z', 'stopped', :root)`,
+  ).run({ ":root": base });
+  adapter.prepare(
+    `INSERT INTO unit_dispatches
+      (trace_id, worker_id, milestone_lease_token, milestone_id, unit_type, unit_id, status, attempt_n, started_at, ended_at)
+     VALUES
+      ('trace', 'w1', 1, 'M001', 'complete-milestone', 'M001', 'completed', 1, '2026-05-30T00:00:00.000Z', '2026-05-30T00:01:00.000Z')`,
+  ).run();
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.match(result.blockers.join("\n"), /completed complete-milestone dispatch history/);
+});
+
+test("ADR-017: synthetic parallel-research slice directory is ignored", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parallel-sentinel-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "parallel-research", "tasks"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(
+    existsSync(join(base, ".gsd", "milestones", "M001", "slices", "parallel-research")),
+    true,
+    "sentinel directory is left alone, not treated as a real disk-only slice",
+  );
+  assert.equal(result.repaired.some((record) => record.kind === "disk-slice-id-divergence"), false);
+});
+
 // ─── #5707: caller closure (reconcileBeforeSpawn) ────────────────────────────
 
 test("ADR-017 (#5707): reconcileBeforeSpawn returns ok=true on clean reconciliation", async () => {