gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.b6ad8c5f7

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -126,6 +126,43 @@ test("uses explicit tier_models when configured", () => {
   assert.equal(result.wasDowngraded, true);
 });
 
+test("preserves explicit provider-qualified tier_models when duplicate bare IDs exist", () => {
+  const config: DynamicRoutingConfig = {
+    ...defaultRoutingConfig(),
+    enabled: true,
+    capability_routing: false,
+    tier_models: {
+      light: "custom-openai/gpt-5.3-codex-spark",
+      standard: "custom-openai/gpt-5.4",
+    },
+  };
+  const providerModels = [
+    "openai-codex/gpt-5.4",
+    "custom-openai/gpt-5.4",
+    "openai-codex/gpt-5.3-codex-spark",
+    "custom-openai/gpt-5.3-codex-spark",
+    "custom-anthropic/claude-opus-4-7",
+  ];
+
+  const standard = resolveModelForComplexity(
+    makeClassification("standard"),
+    { primary: "custom-anthropic/claude-opus-4-7", fallbacks: [] },
+    config,
+    providerModels,
+  );
+  assert.equal(standard.modelId, "custom-openai/gpt-5.4");
+  assert.equal(standard.wasDowngraded, true);
+
+  const light = resolveModelForComplexity(
+    makeClassification("light"),
+    { primary: "custom-anthropic/claude-opus-4-7", fallbacks: [] },
+    config,
+    providerModels,
+  );
+  assert.equal(light.modelId, "custom-openai/gpt-5.3-codex-spark");
+  assert.equal(light.wasDowngraded, true);
+});
+
 // ─── Fallback chain construction ─────────────────────────────────────────────
 
 test("fallback chain includes configured primary as last resort", () => {
@@ -218,6 +255,19 @@ test("defaultRoutingConfig includes capability_routing: true", () => {
   assert.equal(config.capability_routing, true);
 });
 
+test("scoreEligibleModels uses bare capability profiles for provider-qualified IDs", () => {
+  const scored = scoreEligibleModels(
+    ["custom-openai/gpt-5.4", "custom-openai/gpt-5.3-codex-spark"],
+    { coding: 1 },
+  );
+
+  assert.equal(scored[0]?.modelId, "custom-openai/gpt-5.4");
+  assert.ok(
+    (scored[0]?.score ?? 0) > (scored[1]?.score ?? 0),
+    "provider-qualified IDs should still use the built-in bare model capability profile",
+  );
+});
+
 test("scoreModel computes weighted average of capability × requirement", () => {
   const caps: ModelCapabilities = {
     coding: 90, debugging: 80, research: 70,
@@ -298,7 +348,7 @@ test("MODEL_CAPABILITY_PROFILES has entries for all tier-mapped models", () => {
 
 test("#2885: openai-codex light-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const lightModels = ["gpt-4.1-mini", "gpt-4.1-nano", "gpt-5-mini", "gpt-5-nano", "gpt-5.1-codex-mini", "gpt-5.3-codex-spark"];
+  const lightModels = ["gpt-4.1-mini", "gpt-4.1-nano", "gpt-5-mini", "gpt-5-nano", "gpt-5.1-codex-mini", "gpt-5.3-codex-spark", "gpt-5.4-mini"];
   for (const model of lightModels) {
     const result = resolveModelForComplexity(
       makeClassification("light"),

package/src/resources/extensions/gsd/tests/model-unittype-mapping.test.ts

@@ -215,6 +215,65 @@ test("unitVerb handles discuss-slice", () => {
 // auto-artifact-paths.ts: artifact resolution
 // ═══════════════════════════════════════════════════════════════════════════
 
+// ═══════════════════════════════════════════════════════════════════════════
+// ADR-011: meta-test — every KNOWN_UNIT_TYPES entry must appear in all four
+// downstream registries so a future unit type added to KNOWN_UNIT_TYPES can't
+// silently fall through to wrong defaults in metrics/dashboard/artifacts/post-unit.
+// ═══════════════════════════════════════════════════════════════════════════
+
+// Intentional exceptions — unit types that legitimately rely on default/null
+// behavior in a specific registry. Entries captured here reflect the current
+// baseline at the time ADR-011 landed; adding to this allowlist for a NEW unit
+// type requires explicit justification in the commit.
+//
+// Test intent: catch the case where someone adds a new unit type to
+// KNOWN_UNIT_TYPES but forgets to wire it into one of the four registries.
+// The allowlist freezes the baseline so pre-existing omissions do not block
+// the test, but any brand-new addition must be either handled or justified.
+const REGISTRY_EXCEPTIONS: Record<string, Set<string>> = {
+  // metrics.ts classifyUnitPhase uses default → "execution" for most unit types.
+  "metrics.ts": new Set([
+    "worktree-merge", "custom-step",
+    "rewrite-docs", "run-uat", "gate-evaluate", "replan-slice",
+    "reactive-execute", "validate-milestone", "complete-milestone",
+  ]),
+  "auto-dashboard.ts": new Set([
+    "worktree-merge",
+    "gate-evaluate", "reactive-execute", "validate-milestone", "complete-milestone",
+  ]),
+  "auto-artifact-paths.ts": new Set([
+    "rewrite-docs", "gate-evaluate", "reactive-execute", "discuss-slice", "worktree-merge",
+  ]),
+  "auto-post-unit.ts": new Set([
+    "execute-task", "reactive-execute", "gate-evaluate", "worktree-merge",
+  ]),
+};
+
+const REGISTRY_SOURCES: Array<[string, string]> = [
+  ["metrics.ts", metricsSrc],
+  ["auto-dashboard.ts", dashboardSrc],
+  ["auto-artifact-paths.ts", artifactSrc],
+  ["auto-post-unit.ts", postUnitSrc],
+];
+
+test("ADR-011 meta: every KNOWN_UNIT_TYPES entry appears in all 4 downstream registries", () => {
+  const missing: Array<{ registry: string; unitType: string }> = [];
+  for (const [registry, src] of REGISTRY_SOURCES) {
+    for (const ut of ALL_KNOWN_UNIT_TYPES) {
+      if (REGISTRY_EXCEPTIONS[registry]?.has(ut)) continue;
+      if (!src.includes(`"${ut}"`)) {
+        missing.push({ registry, unitType: ut });
+      }
+    }
+  }
+  assert.deepEqual(
+    missing,
+    [],
+    "Each listed unit type is absent from the given registry — either add a handler or add to REGISTRY_EXCEPTIONS with justification:\n" +
+      missing.map((m) => `  ${m.registry}: "${m.unitType}"`).join("\n"),
+  );
+});
+
 test("resolveExpectedArtifactPath handles discuss-slice", () => {
   assert.ok(artifactSrc.includes('"discuss-slice"'), "missing discuss-slice in artifact paths");
 });

package/src/resources/extensions/gsd/tests/notification-overlay.test.ts

@@ -1,31 +1,21 @@
 // GSD Extension — Notification Overlay Tests
-// Tests for message wrapping and content-fit sizing in the notification panel.
+// Tests for message wrapping in the notification panel.
+// Mirrors the private wrapText from notification-overlay.ts so its contract
+// can be exercised without exporting internals.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-// The wrapText function is private to the module, so we test the overlay's
-// render output indirectly. We also extract and test wrapText logic directly.
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 
-// ── wrapText logic (mirrors the private function) ───────────────────────────
+// ── wrapText logic (mirrors the private function in notification-overlay.ts) ──
 
 function wrapText(text: string, maxWidth: number): string[] {
-  if (text.length <= maxWidth) return [text];
-  const words = text.split(/\s+/);
-  const lines: string[] = [];
-  let current = "";
-  for (const word of words) {
-    if (current.length === 0) {
-      current = word;
-    } else if (current.length + 1 + word.length <= maxWidth) {
-      current += " " + word;
-    } else {
-      lines.push(current);
-      current = word;
-    }
-  }
-  if (current.length > 0) lines.push(current);
-  return lines.map((l) => l.length > maxWidth ? l.slice(0, maxWidth - 1) + "…" : l);
+  if (maxWidth <= 0) return [text];
+  const lines = wrapTextWithAnsi(text, maxWidth);
+  return lines.map((l) =>
+    visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l,
+  );
 }
 
 describe("notification overlay — wrapText", () => {
@@ -34,31 +24,26 @@ describe("notification overlay — wrapText", () => {
     assert.deepStrictEqual(result, ["hello world"]);
   });
 
-  test("long text wraps at word boundaries", () => {
+  test("long text wraps at word boundaries without exceeding maxWidth", () => {
     const text = "This is a long notification message that should wrap across multiple lines";
     const result = wrapText(text, 40);
     assert.ok(result.length > 1, `expected multiple lines, got ${result.length}`);
     for (const line of result) {
-      assert.ok(line.length <= 40, `line exceeds maxWidth: "${line}" (${line.length})`);
+      assert.ok(
+        visibleWidth(line) <= 40,
+        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
+      );
     }
   });
 
-  test("single word exceeding maxWidth is truncated", () => {
+  test("single word exceeding maxWidth is broken to fit column budget", () => {
     const result = wrapText("superlongwordthatexceedsmaxwidth", 10);
-    assert.equal(result.length, 1);
-    assert.equal(result[0]!.length, 10);
-    assert.ok(result[0]!.endsWith("…"));
-  });
-
-  test("empty string returns single empty line", () => {
-    const result = wrapText("", 80);
-    assert.deepStrictEqual(result, [""]);
-  });
-
-  test("exact-fit text returns single line", () => {
-    const text = "exactly twenty chars";
-    const result = wrapText(text, 20);
-    assert.deepStrictEqual(result, [text]);
+    for (const line of result) {
+      assert.ok(
+        visibleWidth(line) <= 10,
+        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
+      );
+    }
   });
 
   test("preserves all words across wrapped lines", () => {
@@ -70,4 +55,38 @@ describe("notification overlay — wrapText", () => {
       assert.ok(rejoined.includes(w), `missing word: ${w}`);
     }
   });
+
+  // Regression for #4465 — the previous .length-based wrapper could allow
+  // lines to bleed past the panel border when measured in terminal columns.
+  // Verify that every wrapped line stays within the column budget, including
+  // for the real-world long multi-provider notification payload.
+  test("regression #4465: long notification stays within column budget", () => {
+    const msg =
+      "GSD API Key Manager LLM Providers ✗ anthropic — not configured " +
+      "(console.anthropic.com) ✗ openai — not configured " +
+      "(platform.openai.com/api-keys) ✓ github-copilot — OAuth (expires in 13m) " +
+      "✓ openai-codex — OAuth (expires in 99h 9m) ✓ google-gemini-cli — OAuth " +
+      "(expired — will auto-refresh) ✓ google-antigravity — OAuth " +
+      "(expired — will auto-refresh) ✗ google — not configured " +
+      "(aistudio.google.com/apikey) ✗ groq — not configured";
+    const maxWidth = 118;
+    const result = wrapText(msg, maxWidth);
+    for (const line of result) {
+      assert.ok(
+        visibleWidth(line) <= maxWidth,
+        `line exceeds column budget: visibleWidth=${visibleWidth(line)} max=${maxWidth}: "${line}"`,
+      );
+    }
+  });
+
+  test("unbreakable long token (URL) is clamped to maxWidth", () => {
+    const url = "https://example.com/" + "a".repeat(200);
+    const result = wrapText(url, 40);
+    for (const line of result) {
+      assert.ok(
+        visibleWidth(line) <= 40,
+        `line exceeds maxWidth: visibleWidth=${visibleWidth(line)} line="${line}"`,
+      );
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -17,7 +17,7 @@ test("buildNotificationWidgetLines shows unread count with shortcut pair", () =>
 
     const lines = buildNotificationWidgetLines();
     assert.equal(lines.length, 1);
-    assert.match(lines[0]!, /Notifications:\s+1 unread/);
+    assert.match(lines[0]!, /🔔\s+1 unread/);
     assert.match(lines[0]!, /\(.+\/.+\)/);
   } finally {
     _resetNotificationStore();

package/src/resources/extensions/gsd/tests/onboarding-handler-loader.test.ts

@@ -0,0 +1,41 @@
+import test from "node:test"
+import assert from "node:assert/strict"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+test("onboarding handler resolves wizard module from deployed runtime paths", () => {
+  const source = readFileSync(
+    join(import.meta.dirname, "..", "commands", "handlers", "onboarding.ts"),
+    "utf-8",
+  )
+
+  assert.match(
+    source,
+    /process\.env\.GSD_PKG_ROOT/,
+    "handler should probe GSD_PKG_ROOT for deployed dist\/onboarding.js",
+  )
+
+  assert.match(
+    source,
+    /process\.argv\[1\]/,
+    "handler should fall back to argv-derived package root when env is missing",
+  )
+
+  assert.match(
+    source,
+    /candidates\.push\("\.\.\/\.\.\/\.\.\/\.\.\/\.\.\/onboarding\.js"\)/,
+    "handler must keep the relative source\/dist fallback",
+  )
+
+  assert.match(
+    source,
+    /for \(const specifier of candidates\)/,
+    "handler should try candidates in order",
+  )
+
+  assert.match(
+    source,
+    /Failed to load onboarding wizard module/,
+    "handler should throw a diagnostic error when no candidate resolves",
+  )
+})

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

@@ -0,0 +1,105 @@
+// GSD — Onboarding state record tests.
+// Verifies the explicit completion record (onboarding-state.ts) and step-evolution
+// behavior in setup-catalog.ts, including stale-resume fallback and version semantics.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Tests must isolate per-process to avoid clobbering the user's real ~/.gsd/agent/onboarding.json.
+// We point GSD_HOME at a fresh tmp dir before importing the modules under test.
+const tmpHome = mkdtempSync(join(tmpdir(), "gsd-onboarding-state-test-"));
+process.env.GSD_HOME = tmpHome;
+
+const state = await import("../onboarding-state.ts");
+const catalog = await import("../setup-catalog.ts");
+
+test.after(() => {
+  try { rmSync(tmpHome, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+test("default record returns when no file exists", () => {
+  const r = state.readOnboardingRecord();
+  assert.equal(r.completedAt, null);
+  assert.deepEqual(r.completedSteps, []);
+  assert.equal(r.flowVersion, state.FLOW_VERSION);
+});
+
+test("isOnboardingComplete is false until markOnboardingComplete is called", () => {
+  state.resetOnboarding();
+  assert.equal(state.isOnboardingComplete(), false);
+  state.markOnboardingComplete(["llm"]);
+  assert.equal(state.isOnboardingComplete(), true);
+});
+
+test("markStepCompleted updates lastResumePoint and dedupes", () => {
+  state.resetOnboarding();
+  state.markStepCompleted("llm");
+  state.markStepCompleted("search");
+  state.markStepCompleted("llm"); // dup
+  const r = state.readOnboardingRecord();
+  assert.deepEqual(r.completedSteps.filter(s => s === "llm"), ["llm"]);
+  assert.equal(r.lastResumePoint, "llm"); // last write wins, even on dup
+});
+
+test("markStepSkipped excludes already-completed steps", () => {
+  state.resetOnboarding();
+  state.markStepCompleted("llm");
+  state.markStepSkipped("llm");
+  const r = state.readOnboardingRecord();
+  assert.equal(r.skippedSteps.includes("llm"), false);
+});
+
+test("resetOnboarding clears completion but preserves flowVersion", () => {
+  state.markOnboardingComplete(["llm", "search"]);
+  state.resetOnboarding();
+  const r = state.readOnboardingRecord();
+  assert.equal(r.completedAt, null);
+  assert.deepEqual(r.completedSteps, []);
+  assert.equal(r.flowVersion, state.FLOW_VERSION);
+});
+
+test("flowVersion mismatch invalidates completion (forces re-onboarding)", () => {
+  state.markOnboardingComplete(["llm"]);
+  // Simulate a flow version bump after the user completed an older flow.
+  state.writeOnboardingRecord({ flowVersion: state.FLOW_VERSION - 1 });
+  assert.equal(state.isOnboardingComplete(), false);
+});
+
+test("nearestResumeStep returns first incomplete when resume point is stale", () => {
+  // Stale ID — not in catalog
+  const next = catalog.nearestResumeStep("nonexistent-step", []);
+  assert.equal(next, "llm"); // first step in ONBOARDING_STEPS
+});
+
+test("nearestResumeStep skips already-completed steps from the resume point", () => {
+  const completed = ["llm", "model"];
+  const next = catalog.nearestResumeStep("llm", completed);
+  // First step at-or-after llm that isn't in completed
+  assert.equal(next, "search");
+});
+
+test("nearestResumeStep wraps to start when everything from the point is complete", () => {
+  const allDone = catalog.ONBOARDING_STEPS.map(s => s.id);
+  const next = catalog.nearestResumeStep("llm", allDone.slice(0, allDone.length - 1));
+  // Only the last step is incomplete
+  assert.equal(next, allDone[allDone.length - 1]);
+});
+
+test("isValidStepId accepts catalog ids and rejects others", () => {
+  assert.equal(catalog.isValidStepId("llm"), true);
+  assert.equal(catalog.isValidStepId("tool-keys"), true);
+  assert.equal(catalog.isValidStepId("garbage"), false);
+});
+
+test("corrupt onboarding.json falls back to defaults instead of crashing", async () => {
+  const { writeFileSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const filePath = join(tmpHome, "agent", "onboarding.json");
+  writeFileSync(filePath, "{ this is not json", "utf-8");
+  const r = state.readOnboardingRecord();
+  assert.equal(r.completedAt, null);
+  assert.deepEqual(r.completedSteps, []);
+});

package/src/resources/extensions/gsd/tests/plan-milestone-boundary-map-preservation.test.ts

@@ -0,0 +1,114 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { openDatabase, closeDatabase } from '../gsd-db.ts';
+import { handlePlanMilestone } from '../tools/plan-milestone.ts';
+
+const boundaryMap = [
+  '| From | To | Produces | Consumes |',
+  '|------|----|----------|----------|',
+  '| S01 | S02 | roadmap | plan |',
+  '| S02 | S03 | plan | tasks |',
+  '',
+  '### S01 → S02',
+  '',
+  '- Produces: roadmap',
+  '- Consumes: plan',
+  '',
+  '### S02 → S03',
+  '',
+  '- Produces: plan',
+  '- Consumes: tasks',
+].join('\n');
+
+function planParams() {
+  return {
+    milestoneId: 'M001',
+    title: 'Preserve Boundary Map',
+    vision: 'Roadmap survives projection hook.',
+    successCriteria: ['Boundary Map section survives post-mutation hook'],
+    keyRisks: [
+      { risk: 'Projection clobber', whyItMatters: 'Authoritative roadmap would be overwritten.' },
+    ],
+    proofStrategy: [
+      { riskOrUnknown: 'Roadmap overwrite', retireIn: 'S01', whatWillBeProven: 'ROADMAP.md still contains ## Boundary Map after plan-milestone.' },
+    ],
+    verificationContract: 'Contract check',
+    verificationIntegration: 'Integration check',
+    verificationOperational: 'Operational check',
+    verificationUat: 'UAT check',
+    definitionOfDone: ['Regression test green'],
+    requirementCoverage: 'Covers #4402.',
+    boundaryMapMarkdown: boundaryMap,
+    slices: [
+      {
+        sliceId: 'S01',
+        title: 'First',
+        risk: 'low',
+        depends: [] as string[],
+        demo: 'demo 1',
+        goal: 'goal 1',
+        successCriteria: 'sc 1',
+        proofLevel: 'unit',
+        integrationClosure: 'ic 1',
+        observabilityImpact: 'oi 1',
+      },
+      {
+        sliceId: 'S02',
+        title: 'Second',
+        risk: 'low',
+        depends: ['S01'],
+        demo: 'demo 2',
+        goal: 'goal 2',
+        successCriteria: 'sc 2',
+        proofLevel: 'unit',
+        integrationClosure: 'ic 2',
+        observabilityImpact: 'oi 2',
+      },
+      {
+        sliceId: 'S03',
+        title: 'Third',
+        risk: 'low',
+        depends: ['S02'],
+        demo: 'demo 3',
+        goal: 'goal 3',
+        successCriteria: 'sc 3',
+        proofLevel: 'unit',
+        integrationClosure: 'ic 3',
+        observabilityImpact: 'oi 3',
+      },
+    ],
+  };
+}
+
+test('#4402 plan-milestone preserves ## Boundary Map after post-mutation projections', async (t) => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-4402-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const result = await handlePlanMilestone(planParams(), base);
+  assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+  const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+  assert.ok(existsSync(roadmapPath), 'ROADMAP.md must exist on disk');
+
+  const roadmap = readFileSync(roadmapPath, 'utf-8');
+
+  assert.match(
+    roadmap,
+    /^## Boundary Map$/m,
+    'final on-disk ROADMAP.md must still contain the Boundary Map heading after projection hook',
+  );
+  assert.match(roadmap, /\| S01 \| S02 \| roadmap \| plan \|/, 'boundary map row S01→S02 must survive');
+  assert.match(roadmap, /\| S02 \| S03 \| plan \| tasks \|/, 'boundary map row S02→S03 must survive');
+  assert.match(roadmap, /^### S01 → S02$/m, 'boundary map edge subsection S01→S02 must survive');
+  assert.match(roadmap, /^### S02 → S03$/m, 'boundary map edge subsection S02→S03 must survive');
+});

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

@@ -92,11 +92,10 @@ test('handlePlanMilestone writes milestone and slice planning state and renders
     assert.ok(existsSync(roadmapPath), 'roadmap should be rendered to disk');
     const roadmap = readFileSync(roadmapPath, 'utf-8');
     assert.match(roadmap, /# M001: DB-backed planning/);
-    assert.match(roadmap, /## Vision/);
-    assert.match(roadmap, /Make planning write through the database\./);
-    assert.match(roadmap, /## Slice Overview/);
-    assert.match(roadmap, /\| S01 \| Tool wiring \| medium \|/);
-    assert.match(roadmap, /\| S02 \| Prompt migration \| low \| S01 \|/);
+    assert.match(roadmap, /\*\*Vision:\*\* Make planning write through the database\./);
+    assert.match(roadmap, /^## Slices$/m);
+    assert.match(roadmap, /- \[ \] \*\*S01: Tool wiring\*\* `risk:medium` `depends:\[\]`/);
+    assert.match(roadmap, /- \[ \] \*\*S02: Prompt migration\*\* `risk:low` `depends:\[S01\]`/);
   } finally {
     cleanup(base);
   }

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

@@ -148,6 +148,23 @@ test('handlePlanSlice surfaces render failures without changing parse-visible ta
   }
 });
 
+test('handlePlanSlice reactivates a deferred parent slice to pending', async (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'deferred', demo: 'Rendered plans exist.' });
+
+  const result = await handlePlanSlice(validParams(), base);
+  assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+  const slice = getSlice('M001', 'S02');
+  assert.ok(slice);
+  assert.equal(slice?.status, 'pending', 'deferred slice must be reactivated to pending so auto-mode can dispatch it');
+  assert.equal(slice?.goal, 'Persist slice planning through the DB.');
+});
+
 test('handlePlanSlice reruns idempotently and refreshes parse-visible state', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));