@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

package/src/resources/extensions/gsd/tests/run-uat-composer.test.ts

@@ -123,6 +123,10 @@ test("#4782 phase 3: buildRunUatPrompt inlines UAT and keeps summary/project con
   // Project path is advertised on-demand; full project body is not inlined.
   assert.match(prompt, /\.gsd\/PROJECT\.md/);
   assert.ok(!prompt.includes("Run-UAT composer fixture project"), "run-uat should not inline full project context");
+
+  assert.match(prompt, /"toolPresentationPlanId": "run-uat\/default-v1"/);
+  assert.match(prompt, /"gsd_uat_result_save"/);
+  assert.match(prompt, /"read"/);
 });
 
 test("#4782 phase 3: buildRunUatPrompt omits optional slice summary when file is missing", async (t) => {

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -7,6 +7,7 @@ import assert from "node:assert/strict";
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
 import { compileUnitToolContract } from "../tool-contract.js";
+import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
@@ -63,10 +64,35 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   assert.equal(result.ok, true);
   assert.equal(result.ok && result.contract.unitType, "execute-task");
   assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, ["gsd_task_complete"]);
+  assert.deepEqual(result.ok && result.contract.forbiddenWorkflowTools, []);
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
 });
 
+test("Tool Contract records high-risk cross-phase tool boundaries without single-owning every tool", () => {
+  const completeSlice = compileUnitToolContract("complete-slice");
+  const runUat = compileUnitToolContract("run-uat");
+
+  assert.equal(completeSlice.ok, true);
+  assert.ok(
+    completeSlice.ok &&
+      completeSlice.contract.forbiddenWorkflowTools.some((tool) => tool.name === "gsd_uat_result_save"),
+    "complete-slice should explicitly forbid saving UAT Assessments",
+  );
+
+  assert.equal(runUat.ok, true);
+  assert.ok(
+    runUat.ok &&
+      runUat.contract.requiredWorkflowTools.includes("gsd_uat_result_save"),
+    "run-uat should own the UAT result-save tool",
+  );
+  assert.ok(
+    runUat.ok &&
+      runUat.contract.forbiddenWorkflowTools.some((tool) => tool.name === "gsd_exec"),
+    "run-uat should prefer typed UAT execution over generic gsd_exec",
+  );
+});
+
 test("Tool Contract fails closed for unknown Units", () => {
   const result = compileUnitToolContract("custom-step");
 
@@ -74,10 +100,20 @@ test("Tool Contract fails closed for unknown Units", () => {
   assert.equal(!result.ok && result.reason, "unknown-unit-type");
 });
 
+test("auto Unit tool scope blocks complete-slice from saving UAT Assessment", () => {
+  const result = shouldBlockAutoUnitToolCall("complete-slice", "gsd_uat_result_save");
+
+  assert.equal(result.block, true);
+  assert.match(result.reason ?? "", /Tool Contract failure/);
+  assert.match(result.reason ?? "", /Run UAT owns persisted UAT Assessment/);
+});
+
 test("Recovery Classification covers ADR-015 failure families", () => {
   const cases = [
     ["invalid tool schema enum", "tool-schema", "stop"],
+    ["Tool Contract failure: complete-slice cannot use gsd_uat_result_save", "tool-contract", "stop"],
     ["deterministic policy rejection", "deterministic-policy", "stop"],
+    ["cannot legally advance because required UAT Assessment artifact is missing", "lifecycle-progression", "stop"],
     ["stale worker lease", "stale-worker", "stop"],
     ["worktree root missing .git", "worktree-invalid", "stop"],
     ["verification drift in state snapshot", "verification-drift", "escalate"],

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -298,6 +298,106 @@ test("session_start installs the welcome screen as the TUI header", async (t) =>
   assert.deepEqual(header.render(123), ["welcome 9.9.9-test none 123"]);
 });
 
+test("session hooks preserve closeout-boundary UI during completion reroot", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-closeout-session-hooks-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  const tempGsdHome = join(dir, "home");
+  mkdirSync(tempGsdHome, { recursive: true });
+  writeFileSync(
+    join(dir, "dist", "welcome-screen.js"),
+    "export function buildWelcomeScreenLines() { return ['welcome header']; }\n",
+    "utf-8",
+  );
+
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const originalGsdPkgRoot = process.env.GSD_PKG_ROOT;
+  process.chdir(dir);
+  process.env.GSD_HOME = tempGsdHome;
+  process.env.GSD_PKG_ROOT = dir;
+  autoSession.reset();
+  autoSession.completionStopInProgress = true;
+  t.after(() => {
+    autoSession.reset();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    if (originalGsdPkgRoot === undefined) delete process.env.GSD_PKG_ROOT;
+    else process.env.GSD_PKG_ROOT = originalGsdPkgRoot;
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  const sessionSwitch = handlers.get("session_switch");
+  assert.ok(sessionStart, "session_start handler must be registered");
+  assert.ok(sessionSwitch, "session_switch handler must be registered");
+
+  const widgetCalls: Array<{ key: string; value: unknown }> = [];
+  let headerInstallCount = 0;
+  const ctx = {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: () => {},
+      setHeader: () => {
+        headerInstallCount++;
+      },
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: (key: string, value: unknown) => {
+        widgetCalls.push({ key, value });
+      },
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+    setCompactionThresholdOverride: () => {},
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  };
+
+  await sessionStart!({}, ctx);
+  assert.equal(
+    headerInstallCount,
+    0,
+    "completion reroot session_start must not reinstall the welcome/project-console header",
+  );
+  assert.ok(
+    widgetCalls.some((call) => call.key === "gsd-health" && call.value === undefined),
+    "completion reroot session_start should hide the ambient health widget",
+  );
+
+  widgetCalls.length = 0;
+  await sessionSwitch!({ reason: "reroot" }, ctx);
+  assert.deepEqual(
+    widgetCalls
+      .filter((call) => call.key === "gsd-progress" || call.key === "gsd-outcome")
+      .map((call) => [call.key, call.value]),
+    [],
+    "completion reroot session_switch must not clear the preserved closeout surface",
+  );
+  assert.ok(
+    widgetCalls.some((call) => call.key === "gsd-health" && call.value === undefined),
+    "completion reroot session_switch should keep the ambient health widget hidden",
+  );
+});
+
 test("session_start and session_switch apply disabled model provider policy from current preferences", async (t) => {
   const dir = join(
     tmpdir(),

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: () => {},
@@ -1300,6 +1352,145 @@ test("ADR-017: orphan task completion artifact fails closed", async (t) => {
   assert.match(result.blockers.join("\n"), /Artifact\/DB status drift/);
 });
 
+test("ADR-017 (#414): failure-path summary artifact blocker matches auto.ts filter phrase", async (t) => {
+  // When gsd_summary_save writes a SUMMARY artifact row for a task that never
+  // called gsd_task_complete, the task stays pending and the artifact DB row
+  // produces an artifact-db-status-divergence blocker. The auto.ts dispatch
+  // wrapper must be able to filter this class of blocker to allow re-dispatch.
+  // If this test fails, update the filter strings in auto.ts to match.
+  const base = mkdtempSync(join(tmpdir(), "gsd-failure-path-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S04"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S04", milestoneId: "M001", title: "Task", status: "pending" });
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks", "T01", "T01-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S04",
+    task_id: "T01",
+    full_content: "# T01 Failure Summary\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for pending-task SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY artifact while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): no-db-tasks summary artifact blocker matches auto.ts filter phrase", async (t) => {
+  // When a slice has SUMMARY artifacts in the DB but no DB tasks, the auto.ts
+  // filter must be able to recognise this as a failure-path case and skip it.
+  const base = mkdtempSync(join(tmpdir(), "gsd-no-db-tasks-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S04"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  // No tasks inserted — slice has SUMMARY artifacts for a task that no longer exists.
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks", "T01", "T01-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S04",
+    task_id: "T01",
+    full_content: "# T01 Failure Summary\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for no-db-tasks SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has task SUMMARY artifacts but no DB tasks/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): task-level on-disk summary blocker matches auto.ts filter phrase", async (t) => {
+  // When gsd_summary_save writes a SUMMARY file to disk for a task that never
+  // called gsd_task_complete, but the artifact DB row was not yet written (or
+  // the process crashed before insertion), reconciliation emits
+  // "has SUMMARY on disk while DB status is". The auto.ts filter must match
+  // this phrase so re-dispatch is not blocked.
+  const base = mkdtempSync(join(tmpdir(), "gsd-task-disk-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S04", "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Failure Summary\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S04", milestoneId: "M001", title: "Task", status: "pending" });
+  // No artifact row inserted — SUMMARY exists only on disk.
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for on-disk task SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY on disk while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
+test("ADR-017 (#414): slice-level on-disk summary blocker matches auto.ts filter phrase", async (t) => {
+  // When a SUMMARY file exists on disk for a slice that is still pending
+  // (no gsd_task_complete for the slice), reconciliation emits
+  // "has SUMMARY on disk while DB status is". The auto.ts filter must match
+  // this phrase so re-dispatch is not blocked.
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-disk-summary-drift-"));
+  t.after(() => cleanup(base));
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S04");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S04-SUMMARY.md"), "# S04 Failure Summary\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Slice", status: "pending" });
+  // No artifact row inserted — SUMMARY exists only on disk.
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(result.blockers.length > 0, "blocker must be produced for on-disk slice SUMMARY drift");
+  const blocker = result.blockers.join("\n");
+  assert.match(
+    blocker,
+    /has SUMMARY on disk while DB status is/,
+    "blocker phrase must match the filter in auto.ts reconcileBeforeDispatch wrapper",
+  );
+});
+
 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));