@opengsd/gsd-pi 1.5.0-dev.4fb2d460 → 1.5.0-dev.c4c8885f

package/src/resources/extensions/gsd/tests/flat-phase-validation-path.test.ts

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { relMilestoneFile, resolveMilestoneFile } from "../paths.ts";
+import { normalizeRealPath, relMilestoneFile, relSliceFile, resolveMilestoneFile, targetMilestoneFile } from "../paths.ts";
 
 function makeFlatPhaseFixture(): { basePath: string; cleanup: () => void } {
   const basePath = mkdtempSync(join(tmpdir(), "flat-phase-validation-"));
@@ -33,42 +33,82 @@ function makeFlatPhaseFixture(): { basePath: string; cleanup: () => void } {
   return { basePath, cleanup: () => rmSync(basePath, { recursive: true, force: true }) };
 }
 
-test("flat-phase: relMilestoneFile resolves to the layout-aware path", () => {
+test("flat-phase: relMilestoneFile resolves to the layout-aware path", (t) => {
   const { basePath, cleanup } = makeFlatPhaseFixture();
-  try {
-    const rel = relMilestoneFile(basePath, "M001", "VALIDATION");
-    assert.equal(rel, ".gsd/phases/01-foo/01-VALIDATION.md");
-    const abs = join(basePath, rel);
-    assert.equal(existsSync(abs), true);
-  } finally {
-    cleanup();
-  }
+  t.after(cleanup);
+
+  const rel = relMilestoneFile(basePath, "M001", "VALIDATION");
+  assert.equal(rel, ".gsd/phases/01-foo/01-VALIDATION.md");
+  const abs = join(basePath, rel);
+  assert.equal(existsSync(abs), true);
+});
+
+test("flat-phase: relMilestoneFile fallback uses the milestone title when no directory exists", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "flat-phase-missing-dir-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+
+  const rel = relMilestoneFile(basePath, "M001", "ROADMAP", "Milestone");
+  assert.equal(rel, ".gsd/phases/01-milestone/01-ROADMAP.md");
 });
 
-test("flat-phase: resolveMilestoneFile finds the on-disk file", () => {
+test("legacy layout: relMilestoneFile fallback stays in milestones when the target dir is missing", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "legacy-missing-dir-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const existingLegacyDir = join(basePath, ".gsd", "milestones", "M002");
+  mkdirSync(existingLegacyDir, { recursive: true });
+  writeFileSync(join(existingLegacyDir, "M002-ROADMAP.md"), "# existing legacy roadmap\n");
+
+  const rel = relMilestoneFile(basePath, "M001", "ROADMAP", "Milestone");
+
+  assert.equal(rel, ".gsd/milestones/M001/M001-ROADMAP.md");
+});
+
+test("legacy layout: relSliceFile fallback uses slices directory when target milestone is missing", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "legacy-missing-slice-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const existingLegacyDir = join(basePath, ".gsd", "milestones", "M002");
+  mkdirSync(existingLegacyDir, { recursive: true });
+  writeFileSync(join(existingLegacyDir, "M002-ROADMAP.md"), "# existing legacy roadmap\n");
+
+  const rel = relSliceFile(basePath, "M001", "S01", "PLAN", "Milestone");
+
+  assert.equal(rel, ".gsd/milestones/M001/slices/S01/S01-PLAN.md");
+});
+
+test("flat-phase: targetMilestoneFile ignores legacy-named compatibility files when writing", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "flat-phase-legacy-named-file-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const phaseDir = join(basePath, ".gsd", "phases", "01-foo");
+  mkdirSync(phaseDir, { recursive: true });
+  writeFileSync(join(phaseDir, "M001-ROADMAP.md"), "# legacy named roadmap\n");
+
+  assert.equal(
+    targetMilestoneFile(basePath, "M001", "ROADMAP", "Foo"),
+    join(normalizeRealPath(phaseDir), "01-ROADMAP.md"),
+  );
+  assert.equal(relMilestoneFile(basePath, "M001", "ROADMAP", "Foo"), ".gsd/phases/01-foo/M001-ROADMAP.md");
+});
+
+test("flat-phase: resolveMilestoneFile finds the on-disk file", (t) => {
   const { basePath, cleanup } = makeFlatPhaseFixture();
-  try {
-    const abs = resolveMilestoneFile(basePath, "M001", "VALIDATION");
-    assert.ok(abs, "resolveMilestoneFile must return a path for the flat-phase fixture");
-    assert.equal(abs!.endsWith("/.gsd/phases/01-foo/01-VALIDATION.md"), true);
-    assert.equal(existsSync(abs!), true);
-  } finally {
-    cleanup();
-  }
+  t.after(cleanup);
+
+  const abs = resolveMilestoneFile(basePath, "M001", "VALIDATION");
+  assert.ok(abs, "resolveMilestoneFile must return a path for the flat-phase fixture");
+  assert.equal(abs!.endsWith("/.gsd/phases/01-foo/01-VALIDATION.md"), true);
+  assert.equal(existsSync(abs!), true);
 });
 
-test("flat-phase: the legacy hardcoded path does NOT resolve (regression for #876)", () => {
+test("flat-phase: the legacy hardcoded path does NOT resolve (regression for #876)", (t) => {
   const { basePath, cleanup } = makeFlatPhaseFixture();
-  try {
-    // This is the path that auto-verification.ts:264-270 used to construct.
-    // It must NOT exist on a flat-phase project — that's the whole bug.
-    const legacyHardcoded = join(basePath, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
-    assert.equal(
-      existsSync(legacyHardcoded),
-      false,
-      "legacy hardcoded path must not exist in flat-phase fixture — if it does, the test fixture is wrong",
-    );
-  } finally {
-    cleanup();
-  }
+  t.after(cleanup);
+
+  // This is the path that auto-verification.ts:264-270 used to construct.
+  // It must NOT exist on a flat-phase project — that's the whole bug.
+  const legacyHardcoded = join(basePath, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  assert.equal(
+    existsSync(legacyHardcoded),
+    false,
+    "legacy hardcoded path must not exist in flat-phase fixture — if it does, the test fixture is wrong",
+  );
 });

package/src/resources/extensions/gsd/tests/integration/paths.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, realpathSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -9,6 +9,7 @@ import {
   gsdProjectionRoot,
   gsdRoot,
   milestonesDir,
+  resolveGsdPathContract,
   resolveSliceFile,
   resolveTaskFile,
   _clearGsdRootCache,
@@ -166,4 +167,90 @@ describe('paths', () => {
       cleanup(root);
     }
   });
+
+  test('Case 9: flat-phase task SUMMARY resolves at phase root despite a stray slices/SID/ dir', () => {
+    const root = tmp();
+    try {
+      // Hybrid flat-phase milestone: phase dir holds flat TID-SUMMARY.md, but a
+      // stray slices/S01/ folder also exists on disk. resolveSlicePath then points
+      // under slices/, so layout (phases/ vs milestones/) — not slicePath===phaseDir
+      // — must decide the flat-phase task summary location.
+      const phaseDir = join(root, ".gsd", "phases", "01-foo");
+      mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
+      const flatSummary = join(phaseDir, "T01-SUMMARY.md");
+      writeFileSync(flatSummary, "# task summary\n");
+
+      _clearGsdRootCache();
+
+      assert.deepStrictEqual(
+        resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
+        flatSummary,
+        "flat-phase TID-SUMMARY.md at phase root is found even when slices/S01/ exists",
+      );
+    } finally { cleanup(root); }
+  });
+
+  test('Case 10: resolveGsdPathContract canonicalizes a symlinked .gsd root (regression #1239)', () => {
+    // WSL / external-state shape: `<projectRoot>/.gsd` is a symlink pointing at a
+    // real directory on another volume. Before #1239 the DB path was built from
+    // the unresolved symlink, so the workflow SQLite handle opened through a
+    // move-prone path and could pick the wrong journal mode / SQLITE_READONLY_DBMOVED.
+    const root = tmp();
+    try {
+      const realState = join(root, "real-state"); // canonical symlink target
+      mkdirSync(join(realState, "milestones"), { recursive: true });
+      const projectRoot = join(root, "project");
+      mkdirSync(projectRoot, { recursive: true });
+      symlinkSync(realState, join(projectRoot, ".gsd"), "dir");
+
+      _clearGsdRootCache();
+      const contract = resolveGsdPathContract(projectRoot);
+
+      const canonicalGsd = realpathSync.native(join(projectRoot, ".gsd"));
+      assert.deepStrictEqual(contract.projectGsd, canonicalGsd,
+        "projectGsd is the realpath'd target, not the unresolved .gsd symlink");
+      assert.deepStrictEqual(contract.projectDb, join(canonicalGsd, "gsd.db"),
+        "projectDb is built from the canonical .gsd root");
+      assert.deepStrictEqual(contract.projectGsd, gsdProjectionRoot(projectRoot),
+        "projectGsd agrees with gsdProjectionRoot on the canonical root");
+      assert.notStrictEqual(contract.projectDb, join(projectRoot, ".gsd", "gsd.db"),
+        "regression #1239: DB must not open through the unresolved .gsd symlink");
+    } finally { cleanup(root); }
+  });
+
+  test('Case 11: resolveGsdPathContract canonicalizes the external-state worktree DB path through a symlinked store (regression #1239)', () => {
+    const root = tmp();
+    const originalStateDir = process.env.GSD_STATE_DIR;
+    try {
+      const stateDir = join(root, "state");
+      process.env.GSD_STATE_DIR = stateDir;
+
+      // The external-state project store `<state>/projects/<hash>` is itself a
+      // symlink to a real directory on another volume (the WSL `.gsd` shape).
+      const realProjectGsd = join(root, "real-projects", "abc123");
+      mkdirSync(realProjectGsd, { recursive: true });
+      mkdirSync(join(stateDir, "projects"), { recursive: true });
+      const storeSymlink = join(stateDir, "projects", "abc123");
+      symlinkSync(realProjectGsd, storeSymlink, "dir");
+
+      const wtRoot = join(storeSymlink, "worktrees", "M002");
+      mkdirSync(join(wtRoot, ".gsd"), { recursive: true });
+
+      _clearGsdRootCache();
+      const contract = resolveGsdPathContract(wtRoot);
+
+      const canonicalStore = realpathSync.native(storeSymlink);
+      assert.ok(contract.isWorktree, "recognized as an external-state worktree layout");
+      assert.deepStrictEqual(contract.projectGsd, canonicalStore,
+        "projectGsd is the realpath'd project store, not the unresolved symlink");
+      assert.deepStrictEqual(contract.projectDb, join(canonicalStore, "gsd.db"),
+        "projectDb is built from the canonical project store");
+      assert.notStrictEqual(contract.projectDb, join(storeSymlink, "gsd.db"),
+        "regression #1239: DB must not open through the unresolved external-state symlink");
+    } finally {
+      if (originalStateDir === undefined) delete process.env.GSD_STATE_DIR;
+      else process.env.GSD_STATE_DIR = originalStateDir;
+      cleanup(root);
+    }
+  });
 });

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/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);