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

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -13,13 +13,12 @@ import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
 import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTasksBySliceIds, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
-import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, gsdProjectionRoot, gsdRoot, buildMilestoneFileName, buildTaskFileName, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, targetMilestoneFile, targetSliceFile, gsdProjectionRoot, gsdRoot, buildTaskFileName, } from "./paths.js";
 import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache, milestonesDir, legacyMilestonesDir, isLegacyMilestonesLayout, resolveMilestonePath, relSliceFile, canonicalPhaseDirName } from "./paths.js";
 import { readCompatMarker, writeCompatMarker, computeProjectionSha } from "./compat/compat-marker.js";
-import { planFileName, milestoneIdToPhaseNum, sliceIdToPlanNum, } from "./layout-policy.js";
 // ─── Compat marker invalidation ───────────────────────────────────────────
 // Every successful projection write pushes its (basePath, projectionPath,
 // entities) here; invalidateCaches() drains it and refreshes .gsd/.compat.json
@@ -134,19 +133,6 @@ function sanitizeInlineRoadmapText(value) {
         .replace(/\s+/g, " ")
         .trim();
 }
-function resolveRoadmapProjectionPath(basePath, milestoneId) {
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const existing = resolveMilestonePath(basePath, milestoneId);
-    const legacyBase = legacyMilestonesDir(basePath);
-    const isLegacyLayout = existing
-        ? existing.startsWith(legacyBase + "/") || existing.startsWith(legacyBase + "\\")
-        : isLegacyMilestonesLayout(basePath);
-    const phaseDir = existing ?? join(isLegacyLayout ? legacyBase : milestonesDir(basePath), isLegacyLayout ? milestoneId : canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    const roadmapFileName = isLegacyLayout
-        ? `${milestoneId}-ROADMAP.md`
-        : `${String(phaseNum).padStart(2, "0")}-ROADMAP.md`;
-    return join(phaseDir, roadmapFileName);
-}
 function isMilestoneFlatPhaseLayout(basePath, milestoneId) {
     const existing = resolveMilestonePath(basePath, milestoneId);
     const legacyBase = legacyMilestonesDir(basePath);
@@ -492,7 +478,7 @@ export async function renderRoadmapFromDb(basePath, milestoneId) {
     // clear "write the ROADMAP" failure) instead of a misleading stub.
     if (slices.length === 0 && !milestone.vision.trim()) {
         logWarning("projection", `renderRoadmapFromDb skipped unplanned milestone ${milestoneId} (zero slices, empty vision) — refusing to write a stub ROADMAP`);
-        const absPath = resolveRoadmapProjectionPath(basePath, milestoneId);
+        const absPath = targetMilestoneFile(basePath, milestoneId, "ROADMAP", milestone.title);
         if (existsSync(absPath)) {
             const artifactPath = toArtifactPath(absPath, basePath);
             unlinkSync(absPath);
@@ -506,7 +492,7 @@ export async function renderRoadmapFromDb(basePath, milestoneId) {
         }
         return { skipped: "unplanned-milestone" };
     }
-    const absPath = resolveRoadmapProjectionPath(basePath, milestoneId);
+    const absPath = targetMilestoneFile(basePath, milestoneId, "ROADMAP", milestone.title);
     const artifactPath = toArtifactPath(absPath, basePath);
     const content = renderRoadmapMarkdown(milestone, slices);
     await writeAndStore(absPath, artifactPath, content, {
@@ -536,21 +522,15 @@ export async function renderMilestoneArtifactsFromDb(basePath, milestoneId) {
     const artifacts = getMilestoneScopedArtifacts(milestoneId);
     if (artifacts.length === 0)
         return false;
-    const phaseDir = resolveMilestonePath(basePath, milestoneId) ??
-        join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    mkdirSync(phaseDir, { recursive: true });
-    const legacyBase = legacyMilestonesDir(basePath);
-    const isLegacy = phaseDir.startsWith(legacyBase + "/") || phaseDir.startsWith(legacyBase + "\\");
+    const milestone = getMilestone(milestoneId);
     let wrote = false;
     for (const artifact of artifacts) {
         if (artifact.artifact_type === "ROADMAP")
             continue;
         if (!artifact.full_content.trim())
             continue;
-        const fileName = isLegacy
-            ? `${milestoneId}-${artifact.artifact_type}.md`
-            : buildMilestoneFileName(milestoneId, artifact.artifact_type);
-        const absPath = join(phaseDir, fileName);
+        const absPath = targetMilestoneFile(basePath, milestoneId, artifact.artifact_type, milestone?.title);
+        mkdirSync(dirname(absPath), { recursive: true });
         const artifactPath = toArtifactPath(absPath, basePath);
         await writeAndStore(absPath, artifactPath, artifact.full_content, {
             artifact_type: artifact.artifact_type,
@@ -664,20 +644,11 @@ export async function renderSliceSummary(basePath, milestoneId, sliceId) {
     if (!slice) {
         return false; // No slice data — skip silently
     }
-    // Flat-phase: resolve or create the phase dir, since resolveSlicePath only
-    // finds existing dirs. In flat-phase the slice "path" is the phase dir.
-    let slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
-    if (!slicePath) {
-        const mDir = milestonesDir(basePath);
-        const dirName = canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title);
-        slicePath = join(mDir, dirName);
-        mkdirSync(slicePath, { recursive: true });
-    }
+    const milestoneTitle = getMilestone(milestoneId)?.title;
     let wrote = false;
-    // Write SUMMARY — flat-phase: NN-MM-SUMMARY.md inside phase dir
     if (slice.full_summary_md) {
-        const summaryName = planFileName(milestoneIdToPhaseNum(milestoneId), sliceIdToPlanNum(sliceId), "SUMMARY");
-        const summaryAbs = join(slicePath, summaryName);
+        const summaryAbs = targetSliceFile(basePath, milestoneId, sliceId, "SUMMARY", milestoneTitle);
+        mkdirSync(dirname(summaryAbs), { recursive: true });
         const summaryArtifact = toArtifactPath(summaryAbs, basePath);
         await writeAndStore(summaryAbs, summaryArtifact, slice.full_summary_md, {
             artifact_type: "SUMMARY",
@@ -686,10 +657,9 @@ export async function renderSliceSummary(basePath, milestoneId, sliceId) {
         }, basePath);
         wrote = true;
     }
-    // Write UAT — flat-phase: NN-MM-UAT.md inside phase dir
     if (slice.full_uat_md) {
-        const uatName = planFileName(milestoneIdToPhaseNum(milestoneId), sliceIdToPlanNum(sliceId), "UAT");
-        const uatAbs = join(slicePath, uatName);
+        const uatAbs = targetSliceFile(basePath, milestoneId, sliceId, "UAT", milestoneTitle);
+        mkdirSync(dirname(uatAbs), { recursive: true });
         const uatArtifact = toArtifactPath(uatAbs, basePath);
         await writeAndStore(uatAbs, uatArtifact, slice.full_uat_md, {
             artifact_type: "UAT",
@@ -874,7 +844,7 @@ function detectStaleRendersImpl(basePath) {
         // TODO(flat-phase): roadmap checkbox parsing may not match flat-phase
         // roadmap format, causing false-positive drift loops. Skip during transition.
         /*
-        const roadmapPath = resolveRoadmapProjectionPath(basePath, milestone.id);
+        const roadmapPath = targetMilestoneFile(basePath, milestone.id, "ROADMAP", milestone.title);
         if (existsSync(roadmapPath)) {
           try {
             const parsed = parseProjectionByIdentity(roadmapPath, parseRoadmap) as ReturnType<typeof parseRoadmap>;
@@ -961,34 +931,27 @@ function detectStaleRendersImpl(basePath) {
                     }
                 }
             }
-            // Check missing slice summary/UAT files
+            // Check missing slice summary/UAT files. Use the same target helper as
+            // renderSliceSummary so detection and repair agree on flat-phase vs legacy
+            // output locations.
             const sliceRow = getSlice(milestone.id, slice.id);
             if (sliceRow && sliceRow.status === "complete") {
-                // Use the SAME path construction as renderSliceSummary (planFileName format)
-                // so the detector and repair always agree on the file location.
-                const slicePath = resolveSlicePath(basePath, milestone.id, slice.id);
-                if (slicePath) {
-                    const phaseNum = milestoneIdToPhaseNum(milestone.id);
-                    const planNum = sliceIdToPlanNum(slice.id);
-                    if (sliceRow.full_summary_md) {
-                        const summaryName = planFileName(phaseNum, planNum, "SUMMARY");
-                        const summaryAbsPath = join(slicePath, summaryName);
-                        if (!existsSync(summaryAbsPath)) {
-                            stale.push({
-                                path: summaryAbsPath,
-                                reason: `${slice.id} is complete with summary in DB but SUMMARY.md missing on disk`,
-                            });
-                        }
+                if (sliceRow.full_summary_md) {
+                    const summaryAbsPath = targetSliceFile(basePath, milestone.id, slice.id, "SUMMARY", milestone.title);
+                    if (!existsSync(summaryAbsPath)) {
+                        stale.push({
+                            path: summaryAbsPath,
+                            reason: `${slice.id} is complete with summary in DB but SUMMARY.md missing on disk`,
+                        });
                     }
-                    if (sliceRow.full_uat_md) {
-                        const uatName = planFileName(phaseNum, planNum, "UAT");
-                        const uatAbsPath = join(slicePath, uatName);
-                        if (!existsSync(uatAbsPath)) {
-                            stale.push({
-                                path: uatAbsPath,
-                                reason: `${slice.id} is complete with UAT in DB but UAT.md missing on disk`,
-                            });
-                        }
+                }
+                if (sliceRow.full_uat_md) {
+                    const uatAbsPath = targetSliceFile(basePath, milestone.id, slice.id, "UAT", milestone.title);
+                    if (!existsSync(uatAbsPath)) {
+                        stale.push({
+                            path: uatAbsPath,
+                            reason: `${slice.id} is complete with UAT in DB but UAT.md missing on disk`,
+                        });
                     }
                 }
             }
@@ -1013,12 +976,8 @@ export function roadmapRenderMarksSliceDone(roadmapContent, sliceId) {
     return parseRoadmap(roadmapContent).slices.some((slice) => slice.id === sliceId && slice.done);
 }
 export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanData) {
-    // Flat-phase: replan file lives in the phase dir
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const planNum = sliceIdToPlanNum(sliceId);
-    const absPath = join(slicePath, planFileName(phaseNum, planNum, "REPLAN"));
+    const absPath = targetSliceFile(basePath, milestoneId, sliceId, "REPLAN", getMilestone(milestoneId)?.title);
+    mkdirSync(dirname(absPath), { recursive: true });
     const artifactPath = toArtifactPath(absPath, basePath);
     const lines = [];
     lines.push(`# ${sliceId} Replan`);
@@ -1045,24 +1004,8 @@ export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanD
     return { replanPath: absPath, content };
 }
 export async function renderAssessmentFromDb(basePath, milestoneId, sliceId, assessmentData) {
-    // Flat-phase: the assessment file lives in the phase dir, NOT in a slices/SID/
-    // subdir. resolveSlicePath() detects a slices/SID/ dir unconditionally, so a
-    // stray slices/SID/ created by an earlier planning step would send this write
-    // to a hybrid path (wrong dir, flat filename) that verification cannot find.
-    // Guard with the same legacy-base check relSlicePath() uses so flat-phase
-    // milestones always target the phase dir.
-    const mDir = resolveMilestonePath(basePath, milestoneId);
-    const legacyBase = legacyMilestonesDir(basePath);
-    const isLegacyLayout = mDir
-        ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
-        : false;
-    const fallbackDir = join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
-    const slicePath = isLegacyLayout
-        ? (resolveSlicePath(basePath, milestoneId, sliceId) ?? fallbackDir)
-        : (mDir ?? fallbackDir);
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const planNum = sliceIdToPlanNum(sliceId);
-    const absPath = join(slicePath, planFileName(phaseNum, planNum, "ASSESSMENT"));
+    const absPath = targetSliceFile(basePath, milestoneId, sliceId, "ASSESSMENT", getMilestone(milestoneId)?.title);
+    mkdirSync(dirname(absPath), { recursive: true });
     const artifactPath = toArtifactPath(absPath, basePath);
     const lines = [];
     lines.push(`# ${sliceId} Assessment`);

package/dist/resources/extensions/gsd/metrics.js

@@ -172,7 +172,7 @@ export function snapshotUnitMetrics(ctx, unitType, unitId, startedAt, model, opt
         ledger.units.push(unit);
     }
     saveLedger(basePath, ledger);
-    if (isUnifiedAuditEnabled()) {
+    if (isUnifiedAuditEnabled(basePath)) {
         emitUokAuditEvent(basePath, buildAuditEnvelope({
             traceId: opts?.traceId ?? `metrics:${unitType}:${unitId}`,
             turnId: opts?.turnId,
@@ -324,7 +324,7 @@ export function snapshotUnitMetricsByScope(scope, ctx, unitType, unitId, started
         scopedLedger.units.push(unit);
     }
     saveLedger(base, scopedLedger);
-    if (isUnifiedAuditEnabled()) {
+    if (isUnifiedAuditEnabled(base)) {
         emitUokAuditEvent(base, buildAuditEnvelope({
             traceId: opts?.traceId ?? `metrics:${unitType}:${unitId}`,
             turnId: opts?.turnId,

package/dist/resources/extensions/gsd/paths.js

@@ -10,7 +10,7 @@
  * via prefix matching, so existing projects work without migration.
  */
 import { readdirSync, existsSync, realpathSync, statSync, Dirent } from "node:fs";
-import { join, dirname, normalize, resolve } from "node:path";
+import { join, dirname, normalize, relative, resolve } from "node:path";
 import { homedir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { nativeScanGsdTree } from "./native-parser-bridge.js";
@@ -331,21 +331,26 @@ export function resolveGsdPathContract(workRoot, originalProjectRoot) {
     const resolvedWorkRoot = resolve(workRoot || process.cwd());
     const isWorktree = isGsdWorktreePath(resolvedWorkRoot);
     if (isWorktree && !originalProjectRoot?.trim()) {
-        const projectGsd = resolveExternalStateProjectGsdFromWorktreePath(resolvedWorkRoot);
-        if (projectGsd) {
+        const rawProjectGsd = resolveExternalStateProjectGsdFromWorktreePath(resolvedWorkRoot);
+        if (rawProjectGsd) {
+            // Canonicalize the `.gsd` root so the DB path matches what every other
+            // accessor (gsdRoot/gsdProjectionRoot) returns — otherwise an unresolved
+            // symlink (e.g. `/mnt/c/.../.gsd` → native ext4 on WSL) selects the wrong
+            // journal mode and yields a fragile, move-prone handle. See issue #1239.
+            const projectGsd = normalizeRealPath(rawProjectGsd);
             return {
                 projectRoot: dirname(dirname(projectGsd)),
                 workRoot: resolvedWorkRoot,
                 projectGsd,
-                worktreeGsd: join(resolvedWorkRoot, ".gsd"),
+                worktreeGsd: normalizeRealPath(join(resolvedWorkRoot, ".gsd")),
                 projectDb: join(projectGsd, "gsd.db"),
                 isWorktree,
             };
         }
     }
     const projectRoot = resolve(resolveWorktreeProjectRoot(resolvedWorkRoot, originalProjectRoot));
-    const projectGsd = join(projectRoot, ".gsd");
-    const worktreeGsd = isWorktree ? join(resolvedWorkRoot, ".gsd") : null;
+    const projectGsd = normalizeRealPath(join(projectRoot, ".gsd"));
+    const worktreeGsd = isWorktree ? normalizeRealPath(join(resolvedWorkRoot, ".gsd")) : null;
     return {
         projectRoot,
         workRoot: resolvedWorkRoot,
@@ -879,11 +884,22 @@ export function resolveTasksDir(basePath, milestoneId, sliceId) {
  * Resolve a specific task file.
  */
 export function resolveTaskFile(basePath, milestoneId, sliceId, taskId, suffix) {
-    const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
-    if (!tDir)
+    const phaseDir = resolveMilestonePath(basePath, milestoneId);
+    if (!phaseDir)
         return null;
-    const file = resolveFile(tDir, taskId, suffix);
-    return file ? join(tDir, file) : null;
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = phaseDir.startsWith(legacyBase + "/") || phaseDir.startsWith(legacyBase + "\\");
+    if (suffix !== "PLAN" && !isLegacy) {
+        const flatPath = join(phaseDir, buildTaskFileName(taskId, suffix));
+        return existsSync(flatPath) ? flatPath : null;
+    }
+    const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (tDir) {
+        const file = resolveFile(tDir, taskId, suffix);
+        if (file)
+            return join(tDir, file);
+    }
+    return null;
 }
 // ─── Relative Path Builders (for prompts — .gsd/milestones/...) ────────────
 /**
@@ -915,29 +931,30 @@ export function relMilestonePath(basePath, milestoneId, title) {
     return `.gsd/${LAYOUT_SEGMENTS.level1}/${canonicalPhaseDirName(milestoneId, title)}`;
 }
 /**
- * Build relative .gsd/ path to a milestone file.
- * Layout-aware: uses resolveMilestoneFile to find NN-SUFFIX.md (flat-phase)
- * or M001-SUFFIX.md (legacy). Falls back to a layout-appropriate canonical
- * name when the file doesn't exist yet.
- */
-export function relMilestoneFile(basePath, milestoneId, suffix) {
-    const mRel = relMilestonePath(basePath, milestoneId);
-    // resolveMilestoneFile checks NN-SUFFIX.md (flat-phase) and MID-SUFFIX.md (legacy).
-    const absFile = resolveMilestoneFile(basePath, milestoneId, suffix);
-    if (absFile) {
-        const fileName = absFile.split(/[/\\]/).pop();
-        return `${mRel}/${fileName}`;
-    }
-    // File doesn't exist yet — use layout-aware fallback filename.
+ * Build the canonical absolute write target for a milestone file.
+ * Existing compatibility filenames are intentionally ignored; readers that need
+ * to preserve an existing file should call resolveMilestoneFile first.
+ */
+export function targetMilestoneFile(basePath, milestoneId, suffix, title) {
     const mDir = resolveMilestonePath(basePath, milestoneId);
     const legacyBase = legacyMilestonesDir(basePath);
     const isLegacy = mDir
         ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
-        : false;
+        : isLegacyMilestonesLayout(basePath);
+    const dir = mDir ?? join(isLegacy ? legacyBase : milestonesDir(basePath), isLegacy ? milestoneId : canonicalPhaseDirName(milestoneId, title));
     const fileName = isLegacy
         ? `${milestoneId}-${suffix}.md`
         : `${String(milestoneIdToPhaseNum(milestoneId)).padStart(2, "0")}-${suffix}.md`;
-    return `${mRel}/${fileName}`;
+    return join(dir, fileName);
+}
+/**
+ * Build relative .gsd/ path to a milestone file.
+ * Preserves an existing compatibility filename when present; otherwise falls
+ * back to the canonical write target.
+ */
+export function relMilestoneFile(basePath, milestoneId, suffix, title) {
+    const rel = relative(gsdProjectionRoot(basePath), resolveMilestoneFile(basePath, milestoneId, suffix) ?? targetMilestoneFile(basePath, milestoneId, suffix, title)).replace(/\\/g, "/");
+    return `.gsd/${rel}`;
 }
 /**
  * Build relative .gsd/ path to a slice directory.
@@ -965,32 +982,36 @@ export function relSlicePath(basePath, milestoneId, sliceId, milestoneTitle) {
     return relMilestonePath(basePath, milestoneId, milestoneTitle);
 }
 /**
- * Build relative .gsd/ path to a slice file.
- * Layout-aware: legacy uses S01-SUFFIX.md; flat-phase uses NN-MM-SUFFIX.md.
- *
- * @param milestoneTitle - Optional milestone title forwarded to relSlicePath /
- *   relMilestonePath for title-aware flat-phase fallback dir naming. Only used
- *   when the phase directory does not yet exist on disk.
+ * Build the canonical absolute write target for a slice file.
+ * Existing compatibility filenames are intentionally ignored; readers that need
+ * to preserve an existing file should call resolveSliceFile first.
  */
-export function relSliceFile(basePath, milestoneId, sliceId, suffix, milestoneTitle) {
-    const sRel = relSlicePath(basePath, milestoneId, sliceId, milestoneTitle);
-    const absPath = resolveSliceFile(basePath, milestoneId, sliceId, suffix);
-    if (absPath) {
-        const fileName = absPath.split(/[/\\]/).pop();
-        return `${sRel}/${fileName}`;
-    }
-    // Fallback when file doesn't exist yet — use layout-aware filename.
+export function targetSliceFile(basePath, milestoneId, sliceId, suffix, milestoneTitle) {
     const mDir = resolveMilestonePath(basePath, milestoneId);
     const legacyBase = legacyMilestonesDir(basePath);
     const isLegacy = mDir
         ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
-        : false;
-    if (isLegacy) {
-        return `${sRel}/${sliceId}-${suffix}.md`;
-    }
-    const phaseNum = milestoneIdToPhaseNum(milestoneId);
-    const planNum = sliceIdToPlanNum(sliceId);
-    return `${sRel}/${planFileName(phaseNum, planNum, suffix)}`;
+        : isLegacyMilestonesLayout(basePath);
+    const milestoneDir = mDir
+        ?? dirname(targetMilestoneFile(basePath, milestoneId, "ROADMAP", milestoneTitle));
+    const slicesDir = join(milestoneDir, "slices");
+    const dir = isLegacy
+        ? join(slicesDir, resolveDir(slicesDir, sliceId) ?? sliceId)
+        : milestoneDir;
+    const fileName = isLegacy
+        ? `${sliceId}-${suffix}.md`
+        : planFileName(milestoneIdToPhaseNum(milestoneId), sliceIdToPlanNum(sliceId), suffix);
+    return join(dir, fileName);
+}
+/**
+ * Build relative .gsd/ path to a slice file.
+ * Preserves an existing compatibility filename when present; otherwise falls
+ * back to the canonical write target.
+ */
+export function relSliceFile(basePath, milestoneId, sliceId, suffix, milestoneTitle) {
+    const rel = relative(gsdProjectionRoot(basePath), resolveSliceFile(basePath, milestoneId, sliceId, suffix)
+        ?? targetSliceFile(basePath, milestoneId, sliceId, suffix, milestoneTitle)).replace(/\\/g, "/");
+    return `.gsd/${rel}`;
 }
 /**
  * Build relative .gsd/ path to a task file.
@@ -999,7 +1020,7 @@ export function relSliceFile(basePath, milestoneId, sliceId, suffix, milestoneTi
  * Flat-phase:     PLAN → slice plan path (tasks as checkboxes); other suffixes
  *                 (e.g. SUMMARY) → phase dir / TID-SUFFIX.md
  */
-export function relTaskFile(basePath, milestoneId, sliceId, taskId, suffix) {
+export function relTaskFile(basePath, milestoneId, sliceId, taskId, suffix, milestoneTitle) {
     const sDir = resolveSlicePath(basePath, milestoneId, sliceId);
     const phaseDir = resolveMilestonePath(basePath, milestoneId);
     // Legacy: slice path is a slices/SID/ subdir inside the milestone dir
@@ -1011,6 +1032,6 @@ export function relTaskFile(basePath, milestoneId, sliceId, taskId, suffix) {
     if (suffix === "PLAN") {
         return relSliceFile(basePath, milestoneId, sliceId, "PLAN");
     }
-    const relS = relSlicePath(basePath, milestoneId, sliceId);
+    const relS = relSlicePath(basePath, milestoneId, sliceId, milestoneTitle);
     return `${relS}/${buildTaskFileName(taskId, suffix)}`;
 }

package/dist/resources/extensions/gsd/post-unit-hooks.js

@@ -42,6 +42,33 @@ export function persistHookState(basePath) {
 export function restoreHookState(basePath) {
     getOrCreateRegistry().restoreState(basePath);
 }
+/**
+ * Reconcile a restored `activeHook` against the session's sidecar queue.
+ *
+ * The registry persists `activeHook` to disk but the pending hook *dispatch*
+ * lives only on the non-persisted `s.sidecarQueue`. After a pause/resume or
+ * crash-recovery, `restoreHookState` re-hydrates `activeHook` while the dispatch
+ * is gone, so the registry believes a hook is in-flight but nothing will ever
+ * complete it — and the next unrelated unit's close-out is falsely charged
+ * against the stale hook and blocked. Re-enqueue the missing dispatch so the
+ * hook actually runs, restoring the invariant that a persisted `activeHook`
+ * always has a live dispatch (#1246).
+ */
+export function reconcileRestoredHookDispatch(basePath, sidecarQueue) {
+    const dispatch = getOrCreateRegistry().getPendingHookDispatch(basePath);
+    if (!dispatch)
+        return;
+    const alreadyQueued = sidecarQueue.some(item => item.kind === "hook" && item.unitType === dispatch.unitType);
+    if (alreadyQueued)
+        return;
+    sidecarQueue.push({
+        kind: "hook",
+        unitType: dispatch.unitType,
+        unitId: dispatch.unitId,
+        prompt: dispatch.prompt,
+        model: dispatch.model,
+    });
+}
 export function clearPersistedHookState(basePath) {
     getOrCreateRegistry().clearPersistedState(basePath);
 }

package/dist/resources/extensions/gsd/preferences-models.js

@@ -66,6 +66,39 @@ function resolveWinningPhase(models, chain) {
     }
     return undefined;
 }
+/**
+ * Normalize a single model field into a {@link ResolvedModelConfig}.
+ *
+ * Accepts either the legacy bare-string form or the extended object form
+ * (`{ model, provider?, fallbacks? }`). This is the shared normalization used
+ * for phase buckets so sibling single-model fields — `post_unit_hooks[].model`,
+ * `auto_supervisor.model`, and `reactive_execution.subagent_model` — honor
+ * `fallbacks[]` identically rather than accepting a bare string only (#1229).
+ *
+ * Returns undefined for an unset, blank, or model-less field.
+ */
+export function normalizeModelFieldConfig(field) {
+    if (!field)
+        return undefined;
+    if (typeof field === "string") {
+        return field.trim() ? { primary: field, fallbacks: [] } : undefined;
+    }
+    if (!field.model)
+        return undefined;
+    // When provider is explicitly set, prepend it to the model ID so the
+    // resolution code in auto.ts can do an explicit provider match.
+    const primary = field.provider && !field.model.includes("/")
+        ? `${field.provider}/${field.model}`
+        : field.model;
+    // Carry the per-field `thinking` sub-field through so the dispatch site can
+    // prefer it over the session/floor level, mirroring phase-inline thinking
+    // (#1269). `undefined` is preserved as absent so behavior is unchanged.
+    return {
+        primary,
+        fallbacks: field.fallbacks ?? [],
+        ...(field.thinking ? { thinking: field.thinking } : {}),
+    };
+}
 /**
  * Resolve model and fallbacks for a given auto-mode unit type.
  * Returns the primary model and ordered fallbacks, or undefined if not configured.
@@ -73,6 +106,15 @@ function resolveWinningPhase(models, chain) {
  * Supports both legacy string format and extended object format:
  * - Legacy: `planning: claude-opus-4-6`
  * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
+ *
+ * Hook unit types (`hook/<name>`) resolve against the matching
+ * `post_unit_hooks[]` entry's `model` field so hook sessions honor the same
+ * `fallbacks[]` chain as phase buckets — the recovery path can then switch to
+ * a fallback provider instead of hard-failing (and potentially pausing) the
+ * run on a transient provider trip (#1229).
+ *
+ * The synthetic `supervisor` unit type resolves against `auto_supervisor.model`
+ * for supervisor interventions (wrap-up warnings, timeout recovery).
  */
 export function resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, skipProfileDefaults = false) {
     const loadOpts = {
@@ -81,26 +123,25 @@ export function resolveModelWithFallbacksForUnit(unitType, basePath, availableMo
         ...(skipProfileDefaults ? { skipProfileDefaults: true } : {}),
     };
     const prefs = loadEffectiveGSDPreferences(basePath, loadOpts);
+    // Supervisor interventions resolve against `auto_supervisor.model` (#1229).
+    if (unitType === "supervisor") {
+        return normalizeModelFieldConfig(prefs?.preferences?.auto_supervisor?.model);
+    }
+    // Hook sessions resolve against their own `post_unit_hooks[].model` field,
+    // which now shares the phase-bucket object form (#1229).
+    if (unitType.startsWith("hook/")) {
+        const hookName = unitType.slice("hook/".length);
+        const hooks = prefs?.preferences?.post_unit_hooks;
+        const hook = Array.isArray(hooks) ? hooks.find((h) => h.name === hookName) : undefined;
+        return normalizeModelFieldConfig(hook?.model);
+    }
     const chain = phaseChainForUnit(unitType);
     if (!chain)
         return undefined;
     const winner = resolveWinningPhase(prefs?.preferences?.models, chain);
     if (!winner)
         return undefined;
-    const phaseConfig = winner.config;
-    // Normalize: string -> { model, fallbacks: [] }
-    if (typeof phaseConfig === "string") {
-        return { primary: phaseConfig, fallbacks: [] };
-    }
-    // When provider is explicitly set, prepend it to the model ID so the
-    // resolution code in auto.ts can do an explicit provider match.
-    const primary = phaseConfig.provider && !phaseConfig.model.includes("/")
-        ? `${phaseConfig.provider}/${phaseConfig.model}`
-        : phaseConfig.model;
-    return {
-        primary,
-        fallbacks: phaseConfig.fallbacks ?? [],
-    };
+    return normalizeModelFieldConfig(winner.config);
 }
 /**
  * Resolve the explicitly configured reasoning effort for a unit type (ADR-026).
@@ -125,6 +166,13 @@ export function resolveModelWithFallbacksForUnit(unitType, basePath, availableMo
  * applied here.
  */
 export function resolveThinkingLevelForUnit(unitType, basePath, availableModelIds) {
+    // Single-field configs — `auto_supervisor.model` and `post_unit_hooks[].model`
+    // — carry their own inline `thinking` on the object model form and have no
+    // phase-bucket chain, so the walk below never covers them. Resolve their
+    // per-field level directly (#1269).
+    if (unitType === "supervisor" || unitType.startsWith("hook/")) {
+        return resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds)?.thinking;
+    }
     const loadOpts = availableModelIds !== undefined ? { availableModelIds } : undefined;
     const prefs = loadEffectiveGSDPreferences(basePath, loadOpts)?.preferences;
     if (!prefs)
@@ -383,12 +431,15 @@ export function resolveDynamicRoutingConfig() {
 export function resolveAutoSupervisorConfig() {
     const prefs = loadEffectiveGSDPreferences();
     const configured = prefs?.preferences.auto_supervisor ?? {};
+    const modelConfig = normalizeModelFieldConfig(configured.model);
     return {
         soft_timeout_minutes: configured.soft_timeout_minutes ?? 20,
         idle_timeout_minutes: configured.idle_timeout_minutes ?? 10,
         hard_timeout_minutes: configured.hard_timeout_minutes ?? 30,
         stalled_tool_timeout_minutes: configured.stalled_tool_timeout_minutes ?? 5,
-        ...(configured.model ? { model: configured.model } : {}),
+        ...(modelConfig
+            ? { model: modelConfig.primary, modelFallbacks: modelConfig.fallbacks }
+            : {}),
     };
 }
 // ─── Token Profile Resolution ─────────────────────────────────────────────