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

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -250,6 +250,73 @@ test("migration auto-check canonicalizes a legacy descriptor milestone dir (no f
   }
 });
 
+test("migration auto-check recognizes suffixed flat-phase projection directories", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+
+    insertMilestone({
+      id: "M001-re4q3k",
+      title: "Clean GSD Continuation Readiness",
+      status: "complete",
+      planning: { vision: "Keep continuation state readable." },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001-re4q3k",
+      title: "Readiness slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "Readable continuation state.",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001-re4q3k",
+      title: "Readiness task",
+      status: "complete",
+    });
+    insertMilestone({
+      id: "M002-a1rwmq",
+      title: "Support Command Policy Hardening",
+      status: "complete",
+      planning: { vision: "Harden support command policy." },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M002-a1rwmq",
+      title: "Policy slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "Policy is hardened.",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M002-a1rwmq",
+      title: "Policy task",
+      status: "complete",
+    });
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected flat-phase markdown projections to render");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 2, slices: 2, tasks: 2 });
+    assert.deepEqual(result.beforeDb, { milestones: 2, slices: 2, tasks: 2 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("migration auto-check refreshes a stale open DB handle before comparing", async () => {
   const base = makeBase();
   try {
@@ -372,6 +439,30 @@ test("migration auto-check still compares a roadmapless milestone that HAS a DB
   }
 });
 
+test("migration auto-check aligns a roadmapless milestone dir to its suffixed DB row (no false drift)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    // Team-mode suffixed milestone whose markdown dir has no ROADMAP yet (e.g. a
+    // freshly handed-off / zero-slice milestone). Markdown discovers the bare
+    // "M001"; the DB stores the authoritative suffixed "M001-re4q3k". The
+    // bare-to-suffixed alignment must rewrite EVERY markdown set, including the
+    // roadmapless subset, so the discussion-phase exclusion sees the DB row and
+    // does not decrement the milestone count into false drift.
+    insertMilestone({ id: "M001-re4q3k", title: "Suffixed milestone", status: "queued" });
+    writeScratchMilestoneDir(base, "M001", "M001-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 0, tasks: 0 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 0, tasks: 0 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("rebuildMarkdownProjectionsFromDb realigns markdown when DB holds extra rows", async () => {
   const base = makeBase();
   try {

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

@@ -13,6 +13,7 @@ import {
   isCompletedMilestoneTerminal,
   repairMissingMilestoneSummaryProjection,
 } from "../milestone-closeout.js";
+import { targetMilestoneFile } from "../paths.js";
 import type { DispatchContext } from "../auto-dispatch.js";
 
 /** Build a minimal DispatchContext for the dispatch-policy branches under test. */
@@ -196,7 +197,7 @@ test("repairMissingMilestoneSummaryProjection succeeds when milestone dir does n
   const repair = await repairMissingMilestoneSummaryProjection(base, "M042");
   assert.equal(repair.ok, true, "repair should report success when handler creates the SUMMARY");
   assert.ok(
-    existsSync(join(base, ".gsd", "phases", "42-m042", "42-SUMMARY.md")),
+    existsSync(targetMilestoneFile(base, "M042", "SUMMARY", "Done")),
     "repair should write the SUMMARY artifact to the canonical projection path",
   );
 });

package/src/resources/extensions/gsd/tests/parsers-legacy-importers.test.ts

@@ -65,7 +65,6 @@ const ALLOWED_IMPORTERS = new Set([
   "gsd/visualizer-data.ts",
   // prompt context text (display strings injected into unit prompts)
   "gsd/auto-prompts.ts",
-  // cold-path maintenance command (branch cleanup messaging)
   "gsd/commands-maintenance.ts",
   // display-only GitHub issue/PR body sync
   "github-sync/sync.ts",

package/src/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -16,6 +16,7 @@ import {
   runPreDispatchHooks,
   persistHookState,
   restoreHookState,
+  reconcileRestoredHookDispatch,
   clearPersistedHookState,
   getHookStatus,
   formatHookStatus,
@@ -225,6 +226,233 @@ test('Blocking hook restored from disk does not trust artifact without clean hoo
   }
 });
 
+test('Restore reconciliation re-enqueues the lost hook dispatch (#1246)', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: plan-review
+    after:
+      - plan-slice
+    prompt: Review the plan for {milestoneId}/{sliceId}
+    artifact: PLAN-REVIEW.md
+    criticality: blocking
+    max_cycles: 2
+`);
+    // Trigger unit completes: activeHook set + persisted, dispatch enqueued.
+    const dispatch = checkPostUnitHooks("plan-slice", "M002/S01", base);
+    assert.ok(dispatch, "gate dispatches on trigger unit completion");
+    assert.equal(dispatch.unitType, "hook/plan-review");
+    persistHookState(base);
+
+    // Pause/resume: activeHook restored, but the session-local sidecar queue is
+    // gone (never persisted).
+    resetHookState();
+    restoreHookState(base);
+    assert.ok(getActiveHook(), "activeHook restored from disk");
+
+    // Reconciliation re-enqueues the missing dispatch so the hook actually runs.
+    const sidecarQueue: any[] = [];
+    reconcileRestoredHookDispatch(base, sidecarQueue);
+    assert.equal(sidecarQueue.length, 1, "lost hook dispatch is re-enqueued");
+    assert.equal(sidecarQueue[0].kind, "hook");
+    assert.equal(sidecarQueue[0].unitType, "hook/plan-review");
+    assert.equal(sidecarQueue[0].unitId, "M002/S01");
+    assert.match(sidecarQueue[0].prompt, /Review the plan for M002\/S01/);
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Restore reconciliation is a no-op when the dispatch is already queued (#1246)', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: plan-review
+    after:
+      - plan-slice
+    prompt: Review the plan
+    artifact: PLAN-REVIEW.md
+    criticality: blocking
+    max_cycles: 2
+`);
+    const dispatch = checkPostUnitHooks("plan-slice", "M002/S01", base);
+    assert.ok(dispatch, "gate dispatches on trigger unit completion");
+    persistHookState(base);
+    resetHookState();
+    restoreHookState(base);
+
+    const sidecarQueue: any[] = [
+      { kind: "hook", unitType: "hook/plan-review", unitId: "M002/S01", prompt: "already here" },
+    ];
+    reconcileRestoredHookDispatch(base, sidecarQueue);
+    assert.equal(sidecarQueue.length, 1, "does not duplicate an existing hook dispatch");
+    assert.equal(sidecarQueue[0].prompt, "already here");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Restore reconciliation is a no-op with no active hook (#1246)', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const sidecarQueue: any[] = [];
+    reconcileRestoredHookDispatch(base, sidecarQueue);
+    assert.equal(sidecarQueue.length, 0, "nothing enqueued when no active hook");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook re-dispatches once after a lost dispatch at default max_cycles', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    // Default max_cycles (1): a cycle is charged at dispatch time.
+    writeHookPreferences(base, `  - name: plan-review
+    after:
+      - plan-slice
+    prompt: Review plan
+    artifact: PLAN-REVIEW.md
+    criticality: blocking
+`);
+
+    const firstDispatch = checkPostUnitHooks("plan-slice", "M002/S01", base);
+    assert.ok(firstDispatch, "gate dispatches and consumes its cycle at dispatch");
+    assert.equal(firstDispatch.unitType, "hook/plan-review");
+    persistHookState(base);
+
+    // Simulate a lost dispatch: the hook never produced its own unit-end, the
+    // trigger unit resumes instead. The dispatch-consumed cycle is refunded once
+    // so the gate re-dispatches rather than hard-blocking on a hook that never ran.
+    resetHookState();
+    restoreHookState(base);
+    const redispatch = checkPostUnitHooks("plan-slice", "M002/S01", base);
+    assert.ok(redispatch, "lost dispatch re-dispatches the gate instead of blocking");
+    assert.equal(redispatch.unitType, "hook/plan-review");
+    assert.deepStrictEqual(consumeGateBlock(), null, "no gate block on the first lost dispatch");
+    persistHookState(base);
+
+    // A second lost dispatch consumes the budget and blocks — the refund is one-shot.
+    resetHookState();
+    restoreHookState(base);
+    const blocked = checkPostUnitHooks("plan-slice", "M002/S01", base);
+    assert.deepStrictEqual(blocked, null, "second lost dispatch exhausts the budget");
+    const block = consumeGateBlock();
+    assert.ok(block, "gate block recorded after the one-shot re-dispatch is used");
+    assert.equal(block.hookName, "plan-review");
+    assert.match(block.reason, /gate cycle budget exhausted/);
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook lost-dispatch refund is one-shot and bounded at max_cycles=2', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: plan-review
+    after:
+      - plan-slice
+    prompt: Review plan
+    artifact: PLAN-REVIEW.md
+    criticality: blocking
+    max_cycles: 2
+`);
+
+    // Simulate a lost dispatch: persist, drop in-memory state, restore, then the
+    // trigger unit resumes instead of the hook producing its own unit-end.
+    const lose = () => {
+      persistHookState(base);
+      resetHookState();
+      restoreHookState(base);
+      return checkPostUnitHooks("plan-slice", "M002/S01", base);
+    };
+
+    assert.ok(checkPostUnitHooks("plan-slice", "M002/S01", base), "initial dispatch");
+
+    // Refund is one-shot, but max_cycles=2 still has real budget, so lost#2 also
+    // re-dispatches by consuming a genuine cycle (not another refund).
+    assert.ok(lose(), "lost#1 re-dispatches (one-shot refund)");
+    assert.equal(consumeGateBlock(), null, "no block after lost#1");
+    assert.ok(lose(), "lost#2 re-dispatches from real budget");
+    assert.equal(consumeGateBlock(), null, "no block after lost#2");
+
+    // Total dispatches are bounded to max_cycles + 1 (the single forgiven loss),
+    // so the third lost dispatch blocks. redispatchedGateKeys guarantees this
+    // terminates rather than looping forever on repeated lost resumes.
+    assert.equal(lose(), null, "lost#3 exhausts the bounded budget");
+    const block = consumeGateBlock();
+    assert.ok(block, "gate block recorded on lost#3");
+    assert.match(block.reason, /gate cycle budget exhausted/);
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook lost dispatch does not steal a real-run cycle at max_cycles=2', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: plan-review
+    after:
+      - plan-slice
+    prompt: Review plan
+    artifact: PLAN-REVIEW.md
+    criticality: blocking
+    max_cycles: 2
+`);
+
+    // Dispatch, then lose it once (the one-shot refund is spent here).
+    assert.ok(checkPostUnitHooks("plan-slice", "M002/S01", base), "initial dispatch");
+    persistHookState(base);
+    resetHookState();
+    restoreHookState(base);
+    assert.ok(
+      checkPostUnitHooks("plan-slice", "M002/S01", base),
+      "lost dispatch re-dispatches (refund spent)",
+    );
+
+    // The hook now actually runs, each run reporting a failed verdict. Because a
+    // lost dispatch must not consume the hook's real-run budget, max_cycles=2
+    // still permits two genuine runs before the gate blocks — spending the
+    // refund early did not rob a later real cycle.
+    mkdirSync(join(base, ".gsd", "milestones", "M002", "slices", "S01"), { recursive: true });
+    writeFileSync(
+      resolveHookArtifactPath(base, "M002/S01", "PLAN-REVIEW.md"),
+      "---\nverdict: failed\n---\n\nRejected.\n",
+      "utf-8",
+    );
+    assert.ok(
+      checkPostUnitHooks("hook/plan-review", "M002/S01", base),
+      "real run #1 (failed verdict) re-dispatches",
+    );
+    assert.equal(consumeGateBlock(), null, "no block after the first real run");
+    assert.equal(
+      checkPostUnitHooks("hook/plan-review", "M002/S01", base),
+      null,
+      "real run #2 (failed verdict) exhausts the real budget",
+    );
+    const block = consumeGateBlock();
+    assert.ok(block, "gate block recorded only after two real runs");
+    assert.match(block.reason, /gate cycle budget exhausted/);
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test('Blocking hook needs-rework verdict requests trigger unit retry', () => {
   resetHookState();
   const base = createFixtureBase();
@@ -454,4 +682,45 @@ test('triggerHookManually: with configured hook', () => {
   }
 });
 
+// ─── Hook dispatch results omit a primary-only model (#1229) ───────────────
+// Both the auto-mode (checkPostUnitHooks → _startHook) and manual
+// (triggerHookManually) dispatch paths must NOT carry a resolved primary model
+// on the dispatch result. Emitting the primary alone discards the configured
+// fallbacks[] chain: the auto path would re-apply it over a fallback already
+// selected by selectAndApplyModel, and the manual path (dispatchHookUnit) now
+// resolves the full chain itself. The dispatch result therefore leaves `model`
+// unset so downstream resolution honors fallbacks.
+test('Dispatch results omit primary-only model so fallbacks survive (#1229)', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: code-review
+    after:
+      - execute-task
+    prompt: Review the change
+    artifact: REVIEW-PASS.md
+    model:
+      model: primary-model
+      fallbacks:
+        - fallback-a
+        - fallback-b
+`);
+
+    const autoDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(autoDispatch, "auto-mode dispatches the configured hook");
+    assert.equal(autoDispatch.unitType, "hook/code-review", "auto dispatch is hook-prefixed");
+    assert.equal(autoDispatch.model, undefined, "auto dispatch does not carry a primary-only model");
+
+    resetHookState();
+
+    const manualDispatch = triggerHookManually("code-review", "execute-task", "M001/S01/T01", base);
+    assert.ok(manualDispatch, "manual trigger dispatches the configured hook");
+    assert.equal(manualDispatch.unitType, "hook/code-review", "manual dispatch is hook-prefixed");
+    assert.equal(manualDispatch.model, undefined, "manual dispatch does not carry a primary-only model");
+  } finally {
+    resetHookState();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 });

package/src/resources/extensions/gsd/tests/post-unit-retry-on-orchestrator-bridge.test.ts

@@ -260,7 +260,14 @@ test("post-unit blocking gate pauses auto-mode on needs-attention verdict", asyn
     const result = await postUnitPostVerification(pctx);
     assert.equal(result, "stopped");
     assert.equal(pauseAuto.mock.callCount(), 1);
-    assert.match(notifications.join("\n"), /Post-unit gate "review-arbiter" blocked execute-task M001\/S01\/T01/);
+    // Regression (#1245): the block message must name BOTH the hook's trigger
+    // unit (execute-task M001/S01/T01) and the just-completed unit that surfaced
+    // the block (s.currentUnit = hook/review-arbiter M001/S01/T01), so the pause
+    // is unambiguous to triage. The pre-fix message stopped at the trigger unit.
+    assert.match(
+      notifications.join("\n"),
+      /Post-unit gate "review-arbiter" blocked execute-task M001\/S01\/T01 \(detected on completion of hook\/review-arbiter M001\/S01\/T01\)/,
+    );
     assert.match(notifications.join("\n"), /\/gsd status/);
   } finally {
     process.chdir(originalCwd);

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

@@ -24,6 +24,7 @@ import {
   loadProjectGSDPreferences,
   parsePreferencesMarkdown,
   renderPreferencesForSystemPrompt,
+  renderLanguageDirectiveForPrompt,
   clearGSDPreferencesCache,
   _resetParseWarningFlag,
 } from "../preferences.ts";
@@ -1674,6 +1675,24 @@ test("language: renderPreferencesForSystemPrompt omits language line when not se
   assert.ok(!output.includes("Always respond in"), `expected no language line in output, got:\n${output}`);
 });
 
+test("language: renderLanguageDirectiveForPrompt emits directive when language set", () => {
+  const output = renderLanguageDirectiveForPrompt({ language: "Chinese" });
+  assert.ok(output.includes("## Response Language"), `expected language heading, got:\n${output}`);
+  assert.ok(output.includes("Always respond in Chinese"), `expected language instruction, got:\n${output}`);
+});
+
+test("language: renderLanguageDirectiveForPrompt returns empty when language unset", () => {
+  assert.equal(renderLanguageDirectiveForPrompt({}), "");
+  assert.equal(renderLanguageDirectiveForPrompt(undefined), "");
+});
+
+test("language: renderLanguageDirectiveForPrompt sanitizes newlines and caps length", () => {
+  const output = renderLanguageDirectiveForPrompt({ language: `Chinese\ninjected${"x".repeat(80)}` });
+  assert.ok(!output.includes("\ninjected"), `expected newlines stripped, got:\n${output}`);
+  // "Chinese injected" + padding, capped to 50 chars after newline replacement.
+  assert.ok(output.includes("Always respond in Chinese injected"), `got:\n${output}`);
+});
+
 test("language: parses from markdown frontmatter", () => {
   const content = [
     "---",

package/src/resources/extensions/gsd/tests/read-uat-gate-verdict.test.ts

@@ -160,6 +160,60 @@ describe('readUatGateVerdict — DB fallback for orphaned ASSESSMENT', () => {
     assert.equal(result, null, 'roadmap-scoped assessments must not satisfy the UAT gate');
   });
 
+  test('a backfilled assessment does NOT satisfy the UAT gate (#1258)', async () => {
+    // The milestone-validation backfill fabricates a `verdict: PASS` ASSESSMENT
+    // for completed slices that never produced a real UAT result (e.g.
+    // artifact-driven UAT that was never dispatched). Filed under scope
+    // 'backfill', that placeholder must never be read as a genuine UAT sign-off —
+    // otherwise "never checked" is silently treated as "passed". Even with the
+    // fabricated file present on disk, the gate must fall through to the
+    // authoritative run-uat row (absent here) and return null.
+    const file = canonicalAssessmentPath(basePath);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, RUNTIME_PASS_BODY);
+    insertAssessment({
+      path: `.gsd/milestones/${MID}/slices/${SLICE}/${SLICE}-ASSESSMENT.md`,
+      milestoneId: MID,
+      sliceId: SLICE,
+      status: 'pass',
+      scope: 'backfill',
+      fullContent: RUNTIME_PASS_BODY,
+    });
+
+    const result = await readUatGateVerdict(basePath, MID, SLICE);
+
+    assert.equal(result, null, 'backfilled assessments must not satisfy the UAT gate');
+  });
+
+  test('a genuine run-uat row still resolves even when a backfilled file exists (#1258)', async () => {
+    // If a real UAT was later recorded, its authoritative run-uat row must win
+    // over the fabricated placeholder rather than being masked by it.
+    const file = canonicalAssessmentPath(basePath);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, RUNTIME_PASS_BODY);
+    insertAssessment({
+      path: `.gsd/milestones/${MID}/slices/${SLICE}/${SLICE}-ASSESSMENT.md`,
+      milestoneId: MID,
+      sliceId: SLICE,
+      status: 'pass',
+      scope: 'backfill',
+      fullContent: RUNTIME_PASS_BODY,
+    });
+    insertAssessment({
+      path: `.gsd/phases/01-some-feature/01-01-ASSESSMENT.md`,
+      milestoneId: MID,
+      sliceId: SLICE,
+      status: 'pass',
+      scope: 'run-uat',
+      fullContent: RUNTIME_PASS_BODY,
+    });
+
+    const result = await readUatGateVerdict(basePath, MID, SLICE);
+
+    assert.ok(result, 'a genuine run-uat sign-off must resolve');
+    assert.equal(result!.verdict, 'pass');
+  });
+
   test('returns null when no assessment and no file exist (fallback does not hallucinate)', async () => {
     const result = await readUatGateVerdict(basePath, MID, SLICE);
     assert.equal(result, null);

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

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -394,6 +394,54 @@ test('handleReassessRoadmap invalidates stale milestone-validation when roadmap
   }
 });
 
+test('handleReassessRoadmap deletes flat-phase compatibility validation files when roadmap changes (#2957)', async (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice One', status: 'complete', demo: 'Demo' });
+
+  const legacyValidationPath = join(base, '.gsd', 'phases', '01-test', 'M001-VALIDATION.md');
+  const canonicalValidationPath = join(base, '.gsd', 'phases', '01-test', '01-VALIDATION.md');
+  const staleValidation = '---\nverdict: pass\n---\n\n# Stale validation\n';
+  writeFileSync(legacyValidationPath, staleValidation, 'utf-8');
+  writeFileSync(canonicalValidationPath, staleValidation, 'utf-8');
+  insertAssessment({
+    path: legacyValidationPath,
+    milestoneId: 'M001',
+    sliceId: null,
+    taskId: null,
+    status: 'pass',
+    scope: 'milestone-validation',
+    fullContent: staleValidation,
+  });
+
+  const result = await handleReassessRoadmap({
+    milestoneId: 'M001',
+    completedSliceId: 'S01',
+    verdict: 'confirmed',
+    assessment: 'S01 completed. Adding S02 changes roadmap structure.',
+    sliceChanges: {
+      modified: [],
+      added: [
+        {
+          sliceId: 'S02',
+          title: 'New Slice Two',
+          risk: 'low',
+          depends: ['S01'],
+          demo: 'Demo two.',
+        },
+      ],
+      removed: [],
+    },
+  }, base);
+
+  assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+  assert.equal(existsSync(legacyValidationPath), false, 'stale compatibility validation artifact should be deleted');
+  assert.equal(existsSync(canonicalValidationPath), false, 'canonical validation artifact should not remain after reassess');
+});
+
 test('handleReassessRoadmap does NOT invalidate validation when no roadmap structural changes (#2957)', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

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

@@ -125,6 +125,58 @@ test('handleReopenSlice: rejects slice in a closed milestone', async () => {
   }
 });
 
+test('handleReopenSlice: recovers a desynced slice (open status, completed tasks) — #1205', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    // Desync signature: slice left "pending" by a UAT→planning fallback while
+    // its tasks stayed "complete" from the first execution pass.
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'pending' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S01' }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(result.tasksReset, 2, 'both completed tasks should be reset');
+
+    const slice = getSlice('M001', 'S01');
+    assert.equal(slice!.status, 'in_progress', 'slice should be reopened to in_progress');
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.ok(tasks.every(t => t.status === 'pending'), 'all tasks should be reset to pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenSlice: rejects an in-flight slice with mixed task progress and preserves it — #1205', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    // Normal in-flight slice, NOT the #1205 desync: one task finished while
+    // another is still in progress. The desync guard must not treat a single
+    // completed task as reopenable, or a full reset would wipe live progress.
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'in_progress' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'in_progress' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S01' }, base);
+
+    assert.ok('error' in result, 'in-flight slice with unfinished tasks must be rejected');
+    assert.match(result.error, /not complete/);
+
+    // Progress must be untouched — nothing reset to pending.
+    const byId = Object.fromEntries(getSliceTasks('M001', 'S01').map(t => [t.id, t.status]));
+    assert.equal(byId['T01'], 'complete', 'completed task must stay complete');
+    assert.equal(byId['T02'], 'in_progress', 'in-progress task must stay in_progress');
+    assert.equal(getSlice('M001', 'S01')!.status, 'in_progress', 'slice status must be untouched');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handleReopenSlice: rejects reopening a slice that is not complete', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));