@opengsd/gsd-pi 1.5.0 → 1.6.0-dev.aa7f94e8

package/src/resources/extensions/gsd/tests/workflow-projections.test.ts

@@ -6,10 +6,10 @@ import assert from 'node:assert/strict';
 import { existsSync, mkdtempSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { regenerateIfMissing, renderPlanContent, renderStateProjection } from '../workflow-projections.ts';
+import { regenerateIfMissing, renderPlanContent, renderStateProjection, renderSummaryProjection } from '../workflow-projections.ts';
 import type { SliceRow, TaskRow } from '../gsd-db.ts';
 import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from '../gsd-db.ts';
-import { clearPathCache, _clearGsdRootCache } from '../paths.ts';
+import { clearPathCache, _clearGsdRootCache, normalizeRealPath, resolveMilestoneFile, resolveTaskFile } from '../paths.ts';
 import { invalidateStateCache } from '../state.ts';
 import { clearParseCache } from '../files.ts';
 
@@ -243,6 +243,217 @@ test('workflow-projections: regenerateIfMissing PLAN restores slice plan and tas
   }
 });
 
+test('workflow-projections: regenerateIfMissing ROADMAP is idempotent for flat-phase roadmap projections', async () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-projections-flat-roadmap-'));
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  const phaseDir = join(base, '.gsd', 'phases', '01-milestone');
+  mkdirSync(phaseDir, { recursive: true });
+  openDatabase(dbPath);
+  clearParseCache();
+  clearPathCache();
+  _clearGsdRootCache();
+  invalidateStateCache();
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active', planning: { vision: 'Ship a layout-aware roadmap.' } });
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Flat slice',
+      status: 'pending',
+      demo: 'Roadmap exists at the flat-phase path.',
+      planning: { goal: 'Keep ROADMAP regeneration idempotent.' },
+    });
+
+    const roadmapPath = join(phaseDir, '01-ROADMAP.md');
+    writeFileSync(roadmapPath, '# existing flat roadmap\n');
+
+    const regenerated = await regenerateIfMissing(base, 'M001', 'S01', 'ROADMAP');
+
+    assert.equal(regenerated, false, 'existing flat-phase ROADMAP is detected without rewriting');
+    assert.equal(readFileSync(roadmapPath, 'utf-8'), '# existing flat roadmap\n');
+    assert.equal(normalizeRealPath(resolveMilestoneFile(base, 'M001', 'ROADMAP') ?? ''), normalizeRealPath(roadmapPath));
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('workflow-projections: regenerateIfMissing ROADMAP regenerates missing flat-phase roadmap projections', async () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-projections-missing-roadmap-'));
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  const phaseDir = join(base, '.gsd', 'phases', '01-milestone');
+  mkdirSync(phaseDir, { recursive: true });
+  openDatabase(dbPath);
+  clearParseCache();
+  clearPathCache();
+  _clearGsdRootCache();
+  invalidateStateCache();
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active', planning: { vision: 'Ship a layout-aware roadmap.' } });
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Flat slice',
+      status: 'pending',
+      demo: 'Roadmap regenerates at the flat-phase path.',
+      planning: { goal: 'Recover ROADMAP from DB.' },
+    });
+
+    const roadmapPath = join(phaseDir, '01-ROADMAP.md');
+    const legacyRoadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    assert.ok(!existsSync(roadmapPath), 'precondition: flat-phase ROADMAP is absent');
+
+    const regenerated = await regenerateIfMissing(base, 'M001', 'S01', 'ROADMAP');
+
+    assert.equal(regenerated, true, 'missing flat-phase ROADMAP is regenerated');
+    assert.match(readFileSync(roadmapPath, 'utf-8'), /Ship a layout-aware roadmap/);
+    assert.equal(existsSync(legacyRoadmapPath), false, 'regeneration does not create a legacy ROADMAP path');
+    assert.equal(normalizeRealPath(resolveMilestoneFile(base, 'M001', 'ROADMAP') ?? ''), normalizeRealPath(roadmapPath));
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('workflow-projections: regenerateIfMissing SUMMARY is idempotent for flat-phase task summaries', async () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-projections-flat-summary-'));
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  const phaseDir = join(base, '.gsd', 'phases', '01-milestone');
+  mkdirSync(phaseDir, { recursive: true });
+  openDatabase(dbPath);
+  clearParseCache();
+  clearPathCache();
+  _clearGsdRootCache();
+  invalidateStateCache();
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Flat slice',
+      status: 'complete',
+      demo: 'Summary regenerates once.',
+      planning: { goal: 'Recover flat-phase summaries from DB.' },
+    });
+    insertTask({
+      id: 'T01',
+      sliceId: 'S01',
+      milestoneId: 'M001',
+      title: 'Completed task',
+      status: 'complete',
+      oneLiner: 'Completed the flat task.',
+      narrative: 'The task was completed through the DB-backed projection path.',
+      verificationResult: 'passed',
+      duration: '5m',
+      keyFiles: ['src/example.ts'],
+      keyDecisions: ['Use centralized task summary paths.'],
+    });
+
+    const summaryPath = join(phaseDir, 'T01-SUMMARY.md');
+    assert.ok(!existsSync(summaryPath), 'precondition: flat-phase task summary absent');
+
+    const first = await regenerateIfMissing(base, 'M001', 'S01', 'SUMMARY');
+    const second = await regenerateIfMissing(base, 'M001', 'S01', 'SUMMARY');
+
+    assert.equal(first, true, 'first call regenerates the missing task summary');
+    assert.equal(second, false, 'second call sees the flat-phase task summary and does not rewrite it');
+    assert.equal(normalizeRealPath(resolveTaskFile(base, 'M001', 'S01', 'T01', 'SUMMARY') ?? ''), normalizeRealPath(summaryPath));
+    assert.match(readFileSync(summaryPath, 'utf-8'), /# T01: Completed the flat task\./);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('workflow-projections: flat-phase SUMMARY regeneration ignores stale nested task summaries', async () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-projections-flat-stale-nested-'));
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  const phaseDir = join(base, '.gsd', 'phases', '01-milestone');
+  const nestedTasksDir = join(phaseDir, 'tasks');
+  mkdirSync(nestedTasksDir, { recursive: true });
+  writeFileSync(join(nestedTasksDir, 'T01-SUMMARY.md'), '# stale nested summary\n');
+  openDatabase(dbPath);
+  clearParseCache();
+  clearPathCache();
+  _clearGsdRootCache();
+  invalidateStateCache();
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Flat slice',
+      status: 'complete',
+      demo: 'Summary regenerates at phase root.',
+      planning: { goal: 'Recover canonical flat-phase summaries from DB.' },
+    });
+    insertTask({
+      id: 'T01',
+      sliceId: 'S01',
+      milestoneId: 'M001',
+      title: 'Completed task',
+      status: 'complete',
+    });
+
+    const rootSummaryPath = join(phaseDir, 'T01-SUMMARY.md');
+    assert.ok(!existsSync(rootSummaryPath), 'precondition: canonical flat-phase task summary absent');
+
+    const regenerated = await regenerateIfMissing(base, 'M001', 'S01', 'SUMMARY');
+
+    assert.equal(regenerated, true, 'missing phase-root summary is regenerated despite stale nested summary');
+    assert.equal(normalizeRealPath(resolveTaskFile(base, 'M001', 'S01', 'T01', 'SUMMARY') ?? ''), normalizeRealPath(rootSummaryPath));
+    assert.match(readFileSync(rootSummaryPath, 'utf-8'), /# T01: Completed task/);
+    assert.equal(readFileSync(join(nestedTasksDir, 'T01-SUMMARY.md'), 'utf-8'), '# stale nested summary\n');
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('workflow-projections: renderSummaryProjection uses milestone title when creating fresh flat-phase dirs', async () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-projections-fresh-summary-'));
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  mkdirSync(join(base, '.gsd'), { recursive: true });
+  openDatabase(dbPath);
+  clearParseCache();
+  clearPathCache();
+  _clearGsdRootCache();
+  invalidateStateCache();
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Flat slice',
+      status: 'complete',
+    });
+    insertTask({
+      id: 'T01',
+      sliceId: 'S01',
+      milestoneId: 'M001',
+      title: 'Completed task',
+      status: 'complete',
+    });
+
+    const titleSummaryPath = join(base, '.gsd', 'phases', '01-milestone', 'T01-SUMMARY.md');
+    const idSummaryPath = join(base, '.gsd', 'phases', '01-m001', 'T01-SUMMARY.md');
+
+    renderSummaryProjection(base, 'M001', 'S01', 'T01');
+
+    assert.ok(existsSync(titleSummaryPath), 'fresh summary projection uses the milestone title slug');
+    assert.equal(existsSync(idSummaryPath), false, 'fresh summary projection does not create an id-slug orphan dir');
+    assert.equal(normalizeRealPath(resolveTaskFile(base, 'M001', 'S01', 'T01', 'SUMMARY') ?? ''), normalizeRealPath(titleSummaryPath));
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test('workflow-projections: renderStateProjection does not clobber non-empty STATE.md when manifest has milestones', async () => {
   const base = mkdtempSync(join(tmpdir(), 'gsd-projection-stale-'));
   const gsdDir = join(base, '.gsd');

package/src/resources/extensions/gsd/tests/worktree-db-integration.test.ts

@@ -17,7 +17,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import { worktreePath } from "../worktree-manager.ts";
 import {
   copyWorktreeDb,

package/src/resources/extensions/gsd/tests/worktree-db-respawn-truncation.test.ts

@@ -17,7 +17,7 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { syncProjectRootToWorktree } from '../auto-worktree.ts';
+import { syncProjectRootToWorktree } from '../auto-worktree-sync.ts';
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -18,9 +18,7 @@ import {
   reconcileWorktreeDb,
   insertDecision,
 } from "../gsd-db.ts";
-import {
-  _shouldReconcileWorktreeDb,
-} from "../auto-worktree.ts";
+import { _shouldReconcileWorktreeDb } from "../auto-worktree-sync.ts";
 import { isInfrastructureError } from "../auto/infra-errors.ts";
 
 describe("#2823: reconcileWorktreeDb same-file guard", () => {

package/src/resources/extensions/gsd/tests/worktree-expected-warnings.test.ts

@@ -6,7 +6,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 
-import { _isExpectedWorktreeUnlinkError } from "../auto-worktree.ts";
+import { _isExpectedWorktreeUnlinkError } from "../auto-worktree-path-utils.ts";
 import { resolveGitDir } from "../worktree-manager.ts";
 
 describe("worktree expected-condition warning suppression (#3665)", () => {

package/src/resources/extensions/gsd/tests/worktree-git-pathspec.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { _gitPathspecForWorktreePath } from "../auto-worktree.ts";
+import { _gitPathspecForWorktreePath } from "../auto-worktree-path-utils.ts";
 
 function run(cmd: string, args: string[], cwd: string): string {
   return execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();

package/src/resources/extensions/gsd/tests/worktree-main-branch.test.ts

@@ -3,7 +3,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { _resolveAutoWorktreeStartPoint } from "../auto-worktree.ts";
+import { _resolveAutoWorktreeStartPoint } from "../auto-worktree-branch-lifecycle.ts";
 
 test("auto-worktree start point prefers milestone integration branch", () => {
   const startPoint = _resolveAutoWorktreeStartPoint(

package/src/resources/extensions/gsd/tests/worktree-preferences-sync.test.ts

@@ -26,7 +26,7 @@ import { tmpdir } from "node:os";
 import {
   syncGsdStateToWorktree,
   syncWorktreeStateBack,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-sync.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/worktree-reentry.test.ts

@@ -13,7 +13,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { createAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
 import { reenterActiveWorktreeIfNeeded } from "../worktree-reentry.ts";
 
 // Safe: all inputs below are hardcoded test strings, not user input.

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -27,8 +27,11 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { syncProjectRootToWorktree } from '../auto-worktree.ts';
-import { syncGsdStateToWorktree, syncWorktreeStateBack } from '../auto-worktree.ts';
+import {
+  syncGsdStateToWorktree,
+  syncProjectRootToWorktree,
+  syncWorktreeStateBack,
+} from '../auto-worktree-sync.ts';
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 

package/src/resources/extensions/gsd/tests/worktree-sync-overwrite-loop.test.ts

@@ -25,7 +25,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncProjectRootToWorktree } from "../auto-worktree.ts";
+import { syncProjectRootToWorktree } from "../auto-worktree-sync.ts";
 
 function createBase(name: string): string {
   const base = mkdtempSync(join(tmpdir(), `gsd-wt-1886-${name}-`));

package/src/resources/extensions/gsd/tests/worktree-sync-tasks.test.ts

@@ -18,7 +18,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncWorktreeStateBack } from "../auto-worktree.ts";
+import { syncWorktreeStateBack } from "../auto-worktree-sync.ts";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `gsd-sync-test-${prefix}-`));

package/src/resources/extensions/gsd/tool-contract.ts

@@ -85,6 +85,18 @@ export interface UnitWorkflowDispatchReadinessInput {
   activeTools?: string[];
 }
 
+export interface WorkflowDispatchModelContext {
+  provider?: string;
+  baseUrl?: string;
+}
+
+export interface UnitWorkflowDispatchReadinessForModelInput
+  extends Omit<UnitWorkflowDispatchReadinessInput, "provider" | "authMode" | "baseUrl"> {
+  model?: WorkflowDispatchModelContext | null;
+  fallbackModel?: WorkflowDispatchModelContext | null;
+  getProviderAuthMode?: (provider: string) => WorkflowCapabilityOptions["authMode"] | undefined;
+}
+
 export function compileUnitContextContract(unitType: string): UnitContextContractResult {
   const manifest = resolveManifest(unitType);
   if (!manifest) {
@@ -115,6 +127,23 @@ export function getUnitWorkflowDispatchReadinessError(
   );
 }
 
+export function getUnitWorkflowDispatchReadinessErrorForModel(
+  input: UnitWorkflowDispatchReadinessForModelInput,
+): string | null {
+  const provider = input.model?.provider ?? input.fallbackModel?.provider;
+  const baseUrl = input.model?.baseUrl ?? input.fallbackModel?.baseUrl;
+  return getUnitWorkflowDispatchReadinessError({
+    provider,
+    unitType: input.unitType,
+    projectRoot: input.projectRoot,
+    env: input.env,
+    surface: input.surface,
+    authMode: provider ? input.getProviderAuthMode?.(provider) : undefined,
+    baseUrl,
+    activeTools: input.activeTools,
+  });
+}
+
 export function compileUnitToolContract(unitType: string): ToolContractResult {
   const manifest = resolveManifest(unitType);
   const surfaceContract = getUnitToolSurfaceContract(unitType);

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -10,7 +10,6 @@
  * for recovery, and invalidates caches.
  */
 
-import { join } from "node:path";
 import { existsSync } from "node:fs";
 
 import {
@@ -21,7 +20,7 @@ import {
   getLatestAssessmentByScope,
   updateMilestoneStatus,
 } from "../gsd-db.js";
-import { gsdProjectionRoot, clearPathCache, relMilestoneFile } from "../paths.js";
+import { clearPathCache, resolveMilestoneFile, targetMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -210,9 +209,14 @@ export async function handleCompleteMilestone(
   // ── Filesystem operations (outside transaction) ─────────────────────────
   const summaryMd = renderMilestoneSummaryMarkdown(params, completedAt);
 
-  // Layout-aware: flat-phase → phases/NN-slug/NN-SUMMARY.md;
-  // legacy → milestones/MID/MID-SUMMARY.md.
-  const summaryPath = join(artifactBasePath, relMilestoneFile(artifactBasePath, params.milestoneId, "SUMMARY"));
+  const summaryPath =
+    resolveMilestoneFile(artifactBasePath, params.milestoneId, "SUMMARY") ??
+    targetMilestoneFile(
+      artifactBasePath,
+      params.milestoneId,
+      "SUMMARY",
+      getMilestone(params.milestoneId)?.title,
+    );
 
   // Guard (#4598): if SUMMARY.md already exists on disk, do not overwrite it.
   // This handles re-dispatch scenarios (DB/disk state divergence) where a prior

package/src/resources/extensions/gsd/tools/reassess-roadmap.ts

@@ -1,6 +1,6 @@
-import { join } from "node:path";
 import { existsSync, unlinkSync } from "node:fs";
-import { relSliceFile, relMilestoneFile } from "../paths.js";
+import { join } from "node:path";
+import { relSliceFile, resolveMilestoneFile, resolveMilestonePath, targetMilestoneFile } from "../paths.js";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
@@ -290,12 +290,23 @@ export async function handleReassessRoadmap(
       params.sliceChanges.removed.length > 0;
 
     if (hasStructuralChanges) {
-      // Layout-aware: flat-phase → phases/NN-slug/NN-VALIDATION.md; legacy → milestones/MID/MID-VALIDATION.md
-      const validationFile = join(basePath, relMilestoneFile(basePath, params.milestoneId, "VALIDATION"));
-      try {
-        if (existsSync(validationFile)) unlinkSync(validationFile);
-      } catch (e) {
-        logWarning("tool", `validation file cleanup failed: ${(e as Error).message}`);
+      const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+      const validationFiles = new Set([
+        resolveMilestoneFile(basePath, params.milestoneId, "VALIDATION"),
+        targetMilestoneFile(
+          basePath,
+          params.milestoneId,
+          "VALIDATION",
+          getMilestone(params.milestoneId)?.title,
+        ),
+        milestoneDir ? join(milestoneDir, `${params.milestoneId}-VALIDATION.md`) : null,
+      ].filter((file): file is string => Boolean(file)));
+      for (const validationFile of validationFiles) {
+        try {
+          if (existsSync(validationFile)) unlinkSync(validationFile);
+        } catch (e) {
+          logWarning("tool", `validation file cleanup failed: ${(e as Error).message}`);
+        }
       }
     }
 

package/src/resources/extensions/gsd/tools/reopen-slice.ts

@@ -5,6 +5,11 @@
  * tasks back to "pending". This is intentional — if you're reopening a
  * slice, you're re-doing the work. Partial resets create ambiguous state.
  *
+ * Also recovers a desynced slice (#1205): when a UAT→planning fallback leaves
+ * the slice open (e.g. "pending") but its tasks still "complete", this clears
+ * that state so the planner can re-plan without hitting "already complete"
+ * rejections.
+ *
  * The parent milestone must still be open (not complete).
  */
 

package/src/resources/extensions/gsd/tools/reopen-task.ts

@@ -23,9 +23,10 @@ import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { writeReopenReason } from "../reopen-reason.js";
 import { existsSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { resolveTasksDir, clearPathCache } from "../paths.js";
+import { join, basename, dirname } from "node:path";
+import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
 
 export interface ReopenTaskParams {
   milestoneId: string;
@@ -106,10 +107,18 @@ export async function handleReopenTask(
   // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
   // Without this, the DB-filesystem reconciler sees the SUMMARY.md and
   // auto-corrects the task back to "complete", making reopen a no-op (#3161).
+  // Legacy layout keeps the summary under a tasks/ subdir; flat-phase writes
+  // TID-SUMMARY.md directly in the phase dir. A tasks/ subdir may still exist
+  // in flat-phase for auxiliary artifacts — its mere existence must NOT redirect
+  // summary cleanup into tasks/ (#1208).
   try {
-    const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-    if (tasksDir) {
-      const summaryPath = join(tasksDir, `${params.taskId}-SUMMARY.md`);
+    const slicePath = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
+    if (slicePath) {
+      const isLegacySlice = basename(dirname(slicePath)) === "slices";
+      const summaryDir = isLegacySlice
+        ? (resolveTasksDir(basePath, params.milestoneId, params.sliceId) ?? slicePath)
+        : slicePath;
+      const summaryPath = join(summaryDir, `${params.taskId}-SUMMARY.md`);
       if (existsSync(summaryPath)) unlinkSync(summaryPath);
     }
   } catch (cleanupErr) {
@@ -117,6 +126,20 @@ export async function handleReopenTask(
   }
   clearPathCache();
 
+  // ── Persist the reopen reason for the next execute-task dispatch (#1272) ──
+  // Without this, the re-dispatched executor receives the original task plan
+  // and verify command with zero signal that it was reopened — it re-runs the
+  // (still-green) scoped verify and re-completes the task, never touching the
+  // regression the gate actually caught. buildExecuteTaskPrompt claims this
+  // artifact and prepends the diagnosis to the next dispatch.
+  if (params.reason && params.reason.trim() !== "") {
+    try {
+      writeReopenReason(basePath, params.milestoneId, params.sliceId, params.taskId, params.reason);
+    } catch (reasonErr) {
+      logWarning("tool", `reopen-task reason persistence warning: ${(reasonErr as Error).message}`);
+    }
+  }
+
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
     await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -12,15 +12,13 @@
  * despite passing validation.
  */
 
-import { join } from "node:path";
-
 import {
   transaction,
   insertAssessment,
   getMilestoneSlices,
   getMilestone,
 } from "../gsd-db.js";
-import { gsdProjectionRoot, clearPathCache, relMilestoneFile } from "../paths.js";
+import { clearPathCache, targetMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -160,11 +158,12 @@ export async function handleValidateMilestone(
   // worktree exists for this milestone, validation reads/writes the
   // worktree's artifacts instead of stale project-root state.
   const validationMd = renderValidationMarkdown(effectiveParams);
-  // Layout-aware: flat-phase → phases/NN-slug/NN-VALIDATION.md;
-  // legacy → milestones/MID/MID-VALIDATION.md.
-  // join(artifactBasePath, relMilestoneFile) gives the absolute path; relMilestoneFile
-  // returns ".gsd/..."-relative so joining with basePath (project/worktree root) is correct.
-  const validationPath = join(artifactBasePath, relMilestoneFile(artifactBasePath, effectiveParams.milestoneId, "VALIDATION"));
+  const validationPath = targetMilestoneFile(
+    artifactBasePath,
+    effectiveParams.milestoneId,
+    "VALIDATION",
+    getMilestone(effectiveParams.milestoneId)?.title,
+  );
 
   // ── DB write first — matches complete-task/complete-slice pattern ───
   // Write DB before disk so a crash between the two leaves a recoverable
@@ -204,7 +203,12 @@ export async function handleValidateMilestone(
     const projectRoot = resolveWorktreeProjectRoot(basePath);
     if (projectRoot !== artifactBasePath) {
       // Mirror to project root using the project root's layout (same logic as above).
-      const projectValidationPath = join(projectRoot, relMilestoneFile(projectRoot, effectiveParams.milestoneId, "VALIDATION"));
+      const projectValidationPath = targetMilestoneFile(
+        projectRoot,
+        effectiveParams.milestoneId,
+        "VALIDATION",
+        getMilestone(effectiveParams.milestoneId)?.title,
+      );
       try {
         await saveFile(projectValidationPath, validationMd);
       } catch (mirrorErr) {

package/src/resources/extensions/gsd/types.ts

@@ -2,6 +2,11 @@
 // Types consumed by state derivation, file parsing, and status display.
 // Pure interfaces — no logic, no runtime dependencies.
 
+// Type-only import (erased at compile time — no runtime dependency): sibling
+// single-model fields share the phase-bucket object form so they honor
+// `fallbacks[]` (#1229).
+import type { GSDPhaseModelConfig } from "./preferences-types.js";
+
 // ─── Enums & Literal Unions ────────────────────────────────────────────────
 
 export type RiskLevel = "low" | "medium" | "high";
@@ -303,8 +308,13 @@ export interface PostUnitHookConfig {
   prompt: string;
   /** Max times this hook can fire for the same trigger unit. Default 1, max 10. */
   max_cycles?: number;
-  /** Model override for hook sessions. */
-  model?: string;
+  /**
+   * Model override for hook sessions. Accepts a bare model ID or the extended
+   * `{ model, provider?, fallbacks? }` object form so a transient trip of the
+   * primary provider falls back to the next entry instead of hard-failing the
+   * hook (#1229).
+   */
+  model?: string | GSDPhaseModelConfig;
   /** Expected output file name (relative to task/slice dir). Used for idempotency — skip if exists. */
   artifact?: string;
   /** Whether the hook is advisory or blocks unit advancement. Default advisory. */
@@ -505,6 +515,11 @@ export interface PreDispatchResult {
 export interface PersistedHookState {
   /** Cycle counts keyed as "hookName/triggerUnitType/triggerUnitId". */
   cycleCounts: Record<string, number>;
+  /**
+   * Cycle keys already granted a one-shot re-dispatch after a lost/interrupted
+   * dispatch, so the refund is bounded to one per gate across resumes.
+   */
+  redispatchedGateKeys?: string[];
   /** In-flight hook, persisted so blocking gates cannot be skipped after resume. */
   activeHook?: HookExecutionState | null;
   /** Remaining hook queue by hook name and trigger unit. */
@@ -607,8 +622,12 @@ export interface ReactiveExecutionConfig {
   max_parallel: number;
   /** Isolation mode for parallel tasks within a slice. Currently only "same-tree" is supported. */
   isolation_mode: "same-tree";
-  /** Optional model override for subagents spawned during parallel execution. */
-  subagent_model?: string;
+  /**
+   * Optional model override for subagents spawned during parallel execution.
+   * Accepts a bare model ID or the extended `{ model, provider?, fallbacks? }`
+   * object form for parity with phase buckets (#1229).
+   */
+  subagent_model?: string | GSDPhaseModelConfig;
 }
 
 /** Per-slice reactive execution runtime state, persisted to disk. */