@opengsd/gsd-pi 1.4.0 → 1.5.0

package/dist/resources/extensions/gsd/flat-phase-migration.js

@@ -9,16 +9,62 @@ import { migrateFromMarkdown } from "./md-importer.js";
 import { countDbHierarchy } from "./migration-auto-check.js";
 import { logWarning } from "./workflow-logger.js";
 import { LAYOUT_SEGMENTS } from "./layout-policy.js";
-import { canonicalPhaseDirName, milestonesDir, resolveMilestonePath } from "./paths.js";
+import { canonicalPhaseDirName, dirIsContentBearingLegacyMilestone, milestonesDir, resolveMilestonePath, } from "./paths.js";
 const LEGACY_MIGRATING_SEGMENT = "milestones.migrating";
+const RETRYABLE_FS_ERROR_CODES = new Set(["EPERM", "EBUSY", "ENOTEMPTY"]);
+const RM_RETRY_OPTIONS = { recursive: true, force: true, maxRetries: 5, retryDelay: 100 };
+let fsOps = { cpSync, renameSync, rmSync };
+export function _setFlatPhaseMigrationFsOpsForTest(overrides) {
+    const previous = fsOps;
+    fsOps = { ...fsOps, ...overrides };
+    return () => {
+        fsOps = previous;
+    };
+}
 function legacyMigratingPath(basePath) {
     return join(basePath, ".gsd", LEGACY_MIGRATING_SEGMENT);
 }
+function removePathWithRetries(path) {
+    fsOps.rmSync(path, { recursive: true, force: true, maxRetries: RM_RETRY_OPTIONS.maxRetries, retryDelay: RM_RETRY_OPTIONS.retryDelay });
+}
+function isRetryableFsError(err) {
+    const code = err?.code;
+    return typeof code === "string" && RETRYABLE_FS_ERROR_CODES.has(code);
+}
+function movePathWithCopyDeleteFallback(src, dst) {
+    try {
+        fsOps.renameSync(src, dst);
+        return;
+    }
+    catch (err) {
+        if (!isRetryableFsError(err))
+            throw err;
+    }
+    try {
+        fsOps.cpSync(src, dst, { recursive: true, force: true });
+        removePathWithRetries(src);
+    }
+    catch (fallbackErr) {
+        if (existsSync(src) && existsSync(dst)) {
+            try {
+                removePathWithRetries(dst);
+            }
+            catch {
+                // Leave the original error intact; the next run can pre-clean dst.
+            }
+        }
+        throw fallbackErr;
+    }
+}
+function expectedPhaseDirs(basePath) {
+    return getAllMilestones().map((milestone) => resolveMilestonePath(basePath, milestone.id) ??
+        join(milestonesDir(basePath), canonicalPhaseDirName(milestone.id, milestone.title)));
+}
 function hasLegacyMilestoneSubdirs(dirPath) {
     if (!existsSync(dirPath))
         return false;
     try {
-        return readdirSync(dirPath).some(e => statSync(join(dirPath, e)).isDirectory());
+        return readdirSync(dirPath).some((e) => statSync(join(dirPath, e)).isDirectory() && dirIsContentBearingLegacyMilestone(join(dirPath, e)));
     }
     catch {
         return false;
@@ -26,19 +72,24 @@ function hasLegacyMilestoneSubdirs(dirPath) {
 }
 function rollbackPartialMigration(basePath, backupDir, migratingPath) {
     // Remove the partially-written phases/ dir.
-    rmSync(join(basePath, ".gsd", LAYOUT_SEGMENTS.level1), { recursive: true, force: true });
+    try {
+        removePathWithRetries(join(basePath, ".gsd", LAYOUT_SEGMENTS.level1));
+    }
+    catch (removeErr) {
+        logWarning("migration", `rollback: could not remove partial ${LAYOUT_SEGMENTS.level1}/: ${removeErr.message}`);
+    }
     // Restore milestones/ — prefer renaming the preserved migrating copy back.
     const milestonesPath = join(basePath, ".gsd", "milestones");
     try {
         if (migratingPath && existsSync(migratingPath) && !existsSync(milestonesPath)) {
-            renameSync(migratingPath, milestonesPath);
+            movePathWithCopyDeleteFallback(migratingPath, milestonesPath);
             return;
         }
         if (existsSync(backupDir)) {
             cpSync(backupDir, milestonesPath, { recursive: true });
         }
         if (migratingPath && existsSync(migratingPath)) {
-            rmSync(migratingPath, { recursive: true, force: true });
+            removePathWithRetries(migratingPath);
         }
     }
     catch (restoreErr) {
@@ -146,20 +197,29 @@ export async function migrateToFlatPhase(basePath) {
             logWarning("migration", `flat-phase migration backup failed: ${err.message}`);
             throw err;
         }
+        if (existsSync(migratingPath)) {
+            removePathWithRetries(migratingPath);
+        }
         // 3. Rename legacy tree aside before rendering so path resolvers target
         // phases/ instead of writing back into the nested milestones/ layout.
         // Keep the full tree on disk until render+verify succeed (unlike rmSync).
         try {
-            renameSync(milestonesPath, migratingPath);
+            movePathWithCopyDeleteFallback(milestonesPath, migratingPath);
         }
         catch (err) {
             logWarning("migration", `failed to rename legacy milestones/ before render: ${err.message}`);
             throw err;
         }
     }
-    else {
-        // Interrupted run: clear any partial phases/ projection before retrying.
-        rmSync(phasesPath, { recursive: true, force: true });
+    // Clear any stale or partially-rendered flat projection before this run
+    // writes. Verification below checks the current DB render, not leftovers.
+    try {
+        removePathWithRetries(phasesPath);
+    }
+    catch (err) {
+        logWarning("migration", `failed to clear stale phases/ before render: ${err.message}`);
+        rollbackPartialMigration(basePath, backupDir, migratingPath);
+        throw err;
     }
     // 4. Render flat-phase from DB
     let renderResult;
@@ -191,20 +251,11 @@ export async function migrateToFlatPhase(basePath) {
         throw new Error(`flat-phase migration render failed: ${renderResult.errors.slice(0, 3).join("; ")}`);
     }
     const db = countDbHierarchy();
-    let renderedDirCount = 0;
-    try {
-        // /^\d+-/ matches any numeric prefix (01-, 10-, 100-) so M100+ milestones
-        // whose dirs start with "100-slug" are counted correctly.
-        renderedDirCount = readdirSync(phasesPath, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory() && /^\d+-/.test(entry.name)).length;
-    }
-    catch {
-        // phases/ doesn't exist or is unreadable — same as zero dirs
-    }
-    if (db.milestones > 0 && renderedDirCount !== db.milestones) {
-        logWarning("migration", `phases/ dir count mismatch: expected ${db.milestones}, found ${renderedDirCount}`);
+    const missingPhaseDirs = expectedPhaseDirs(basePath).filter((phaseDir) => !existsSync(phaseDir));
+    if (db.milestones > 0 && missingPhaseDirs.length > 0) {
+        logWarning("migration", `flat-phase migration missing ${missingPhaseDirs.length} expected phase dir(s): ${missingPhaseDirs.join(", ")}`);
         rollbackPartialMigration(basePath, backupDir, migratingPath);
-        throw new Error("flat-phase migration verification failed: phases dir milestone count mismatch");
+        throw new Error("flat-phase migration verification failed: missing rendered phase directories");
     }
     if (db.slices > 0 && renderResult.rendered === 0) {
         logWarning("migration", "flat-phase migration verification failed: render produced no artifacts for populated DB");
@@ -213,7 +264,7 @@ export async function migrateToFlatPhase(basePath) {
     }
     // 6. Verified — remove the renamed legacy tree (backup already on disk).
     try {
-        rmSync(migratingPath, { recursive: true, force: true });
+        removePathWithRetries(migratingPath);
     }
     catch (err) {
         logWarning("migration", `flat-phase migration succeeded but could not remove ${LEGACY_MIGRATING_SEGMENT}: ${err.message}`);

package/dist/resources/extensions/gsd/git-service.js

@@ -16,7 +16,7 @@ import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { logWarning } from "./workflow-logger.js";
-import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
+import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "./repository-registry.js";
 import { isGsdGitignored } from "./gitignore.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
@@ -1024,28 +1024,25 @@ export function handleTurnGitActionError(action, err) {
         error: errorWithStreams.stderr?.trim() || errorWithStreams.message || getErrorMessage(err),
     };
 }
+export function isRepositoryDirty(repoRoot) {
+    try {
+        return runGit(repoRoot, ["status", "--porcelain"]).length > 0;
+    }
+    catch {
+        // Fallback preserves legacy behavior if explicit status probing fails.
+        return nativeHasChanges(repoRoot);
+    }
+}
 function collectRepositoryDirtyStatus(basePath) {
     const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
     const registry = createRepositoryRegistryFromPreferences(basePath, preferences);
     const dirtyByRepository = {};
     const registeredRoots = new Set(registry.repositories.map((repo) => resolve(repo.root)));
     for (const repo of registry.repositories) {
-        try {
-            dirtyByRepository[repo.id] = runGit(repo.root, ["status", "--porcelain"]).length > 0;
-        }
-        catch {
-            // Fallback preserves legacy behavior if explicit status probing fails.
-            dirtyByRepository[repo.id] = nativeHasChanges(repo.root);
-        }
+        dirtyByRepository[repo.id] = isRepositoryDirty(repo.root);
     }
     for (const repoRoot of findUndeclaredNestedGitRepositories(registry.projectRoot, registeredRoots)) {
-        let dirty = false;
-        try {
-            dirty = runGit(repoRoot, ["status", "--porcelain"]).length > 0;
-        }
-        catch {
-            dirty = nativeHasChanges(repoRoot);
-        }
+        const dirty = isRepositoryDirty(repoRoot);
         if (!dirty)
             continue;
         const relPath = relative(registry.projectRoot, repoRoot).split(sep).join("/") || repoRoot;
@@ -1098,7 +1095,7 @@ function findUndeclaredNestedGitRepositories(projectRoot, registeredRoots) {
 function runPerRepositoryCommitAction(args) {
     const preferences = loadEffectiveGSDPreferences(args.basePath)?.preferences;
     const registry = createRepositoryRegistryFromPreferences(args.basePath, preferences);
-    const repoIds = args.targetRepositories?.length ? args.targetRepositories : ["project"];
+    const repoIds = args.targetRepositories?.length ? args.targetRepositories : defaultRepositoryTargets(registry);
     const gitPrefs = preferences?.git ?? {};
     const commitMessages = {};
     const commitErrors = {};
@@ -1166,8 +1163,7 @@ export function runTurnGitAction(args) {
                 skippedRepositories: repoCommitResult.skippedRepositories,
             };
         }
-        const primaryMessage = repoCommitResult.commitMessages[args.targetRepositories?.[0] ?? "project"]
-            ?? Object.values(repoCommitResult.commitMessages)[0];
+        const primaryMessage = Object.values(repoCommitResult.commitMessages)[0];
         return {
             action: args.action,
             status: "ok",

package/dist/resources/extensions/gsd/gsd-db.js

@@ -410,6 +410,58 @@ export function insertTask(t) {
 export function updateTaskStatus(milestoneId, sliceId, taskId, status, completedAt) {
     applyStatusTransition({ entity: "task", milestoneId, sliceId, taskId, status, completedAt });
 }
+export function repairTaskCompletionFromSummary(t) {
+    const db = getDbOrNull();
+    if (!db)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    transaction(() => {
+        const seq = db.prepare(`SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence
+       FROM tasks
+       WHERE milestone_id = :mid AND slice_id = :sid`).get({ ":mid": t.milestoneId, ":sid": t.sliceId });
+        db.prepare(`INSERT INTO tasks (
+        milestone_id, slice_id, id, title, status, one_liner, narrative,
+        verification_result, duration, completed_at, blocker_discovered,
+        deviations, known_issues, key_files, key_decisions, full_summary_md,
+        sequence
+      ) VALUES (
+        :milestone_id, :slice_id, :id, :title, 'complete', :one_liner, :narrative,
+        :verification_result, :duration, :completed_at, :blocker_discovered,
+        :deviations, :known_issues, :key_files, :key_decisions, :full_summary_md,
+        :sequence
+      )
+      ON CONFLICT(milestone_id, slice_id, id) DO UPDATE SET
+        title = CASE WHEN NULLIF(:title, '') IS NOT NULL THEN :title ELSE tasks.title END,
+        status = 'complete',
+        one_liner = CASE WHEN NULLIF(:one_liner, '') IS NOT NULL THEN :one_liner ELSE tasks.one_liner END,
+        narrative = CASE WHEN NULLIF(:narrative, '') IS NOT NULL THEN :narrative ELSE tasks.narrative END,
+        verification_result = :verification_result,
+        duration = CASE WHEN NULLIF(:duration, '') IS NOT NULL THEN :duration ELSE tasks.duration END,
+        completed_at = :completed_at,
+        blocker_discovered = :blocker_discovered,
+        deviations = CASE WHEN NULLIF(:deviations, '') IS NOT NULL THEN :deviations ELSE tasks.deviations END,
+        known_issues = CASE WHEN NULLIF(:known_issues, '') IS NOT NULL THEN :known_issues ELSE tasks.known_issues END,
+        key_files = :key_files,
+        key_decisions = :key_decisions,
+        full_summary_md = :full_summary_md`).run({
+            ":milestone_id": t.milestoneId,
+            ":slice_id": t.sliceId,
+            ":id": t.taskId,
+            ":title": t.title ?? "",
+            ":one_liner": t.oneLiner ?? "",
+            ":narrative": t.narrative ?? "",
+            ":verification_result": t.verificationResult,
+            ":duration": t.duration ?? "",
+            ":completed_at": t.completedAt,
+            ":blocker_discovered": t.blockerDiscovered ? 1 : 0,
+            ":deviations": t.deviations ?? "",
+            ":known_issues": t.knownIssues ?? "",
+            ":key_files": JSON.stringify(t.keyFiles ?? []),
+            ":key_decisions": JSON.stringify(t.keyDecisions ?? []),
+            ":full_summary_md": t.fullSummaryMd,
+            ":sequence": seq?.next_sequence ?? 1,
+        });
+    });
+}
 export function setTaskBlockerDiscovered(milestoneId, sliceId, taskId, discovered) {
     if (!getDbOrNull())
         return;

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

@@ -151,6 +151,7 @@ const DOCTOR_FIX_HINTS = {
     state_file_stale: "Run `/gsd doctor fix` to rebuild the projection from the database.",
     state_file_missing: "Run `/gsd doctor fix` to rebuild the projection from the database.",
     projection_drift: "Run `/gsd doctor fix` to rebuild markdown projections from the database (DB is the source of truth).",
+    artifact_user_content_missing: "Doctor cannot recreate user-authored content from the database. Re-run `/gsd discuss` for CONTEXT artifacts or `/gsd auto` for RESEARCH artifacts in that milestone.",
     uat_retry_exhausted: "Review the failing UAT criteria via `/gsd status`, fix the issue, then re-run `/gsd auto`.",
 };
 export function doctorFixHint(code) {

package/dist/resources/extensions/gsd/guided-flow.js

@@ -20,7 +20,7 @@ import { assessInterruptedSession, formatInterruptedSessionRunningMessage, forma
 import { listUnitRuntimeRecords, clearUnitRuntimeRecord, isInFlightRuntimePhase } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath } from "./auto.js";
 import { gsdHome } from "./gsd-home.js";
-import { gsdRoot, milestonesDir, legacyMilestonesDir, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, } from "./paths.js";
+import { gsdRoot, milestonesDir, legacyMilestonesDir, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
@@ -53,6 +53,7 @@ import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
 import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
+import { countPlanMilestoneRoadmapSlices } from "./artifact-verification.js";
 import { clearPendingGate, extractDepthVerificationMilestoneId, getPendingGate } from "./bootstrap/write-gate.js";
 import { _getPendingAutoStart, deletePendingAutoStart, hasPendingAutoStart, setPendingAutoStart, } from "./pending-auto-start.js";
 import { clearGuidedUnitContext, setGuidedUnitContext } from "./guided-unit-context.js";
@@ -78,20 +79,57 @@ export const _scheduleAutoStartAfterIdleForTest = scheduleAutoStartAfterIdle;
 // These thin wrappers accept a MilestoneScope so callers that already hold a
 // pinned scope never have to re-derive (basePath, milestoneId) separately.
 // The underlying implementations in auto-recovery.ts / auto-artifact-paths.ts /
-// state.ts are unchanged — only the call surface in guided-flow.ts is migrated.
+// state.ts remain the default for non-scope-specific units.
 /**
  * Scope-based overload of verifyExpectedArtifact.
  * Uses scope.workspace.projectRoot as the authoritative base path, making
  * the check immune to cwd-drift and worktree-path divergence.
  */
 export function verifyExpectedArtifactForScope(scope, unitType, unitId) {
+    if (unitId === scope.milestoneId &&
+        (unitType === "discuss-milestone" || unitType === "plan-milestone")) {
+        // Layout-aware scope paths use resolveMilestoneFile; clear stale dir listings
+        // primed before discuss/plan wrote CONTEXT.md or ROADMAP.md (see checkAutoStartAfterDiscuss).
+        clearPathCache();
+    }
+    if (unitId === scope.milestoneId &&
+        unitType === "discuss-milestone") {
+        const path = resolveExpectedArtifactPathForScope(scope, unitType, unitId);
+        return path ? existsSync(path) : false;
+    }
+    if (unitId === scope.milestoneId && unitType === "plan-milestone") {
+        const path = resolveExpectedArtifactPathForScope(scope, unitType, unitId);
+        return verifyScopedPlanMilestoneArtifact(path, unitType, unitId);
+    }
     return verifyExpectedArtifact(unitType, unitId, scope.workspace.projectRoot);
 }
+function verifyScopedPlanMilestoneArtifact(path, unitType, unitId) {
+    if (!path || !existsSync(path))
+        return false;
+    try {
+        const roadmapContent = readFileSync(path, "utf-8");
+        if (countPlanMilestoneRoadmapSlices(roadmapContent) === 0) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${path}`);
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
 /**
  * Scope-based overload of resolveExpectedArtifactPath.
  * Returns the canonical absolute path (or null) using the scope's projectRoot.
  */
 export function resolveExpectedArtifactPathForScope(scope, unitType, unitId) {
+    if (unitId === scope.milestoneId) {
+        if (unitType === "discuss-milestone")
+            return scope.contextFile();
+        if (unitType === "plan-milestone")
+            return scope.roadmapFile();
+    }
     return resolveExpectedArtifactPath(unitType, unitId, scope.workspace.projectRoot);
 }
 async function runQuickTaskChoice(ctx, pi) {

package/dist/resources/extensions/gsd/key-manager.js

@@ -19,6 +19,7 @@ export const PROVIDER_REGISTRY = [
     // must be in the canonical registry so all consumers see the same catalog.
     // See: https://github.com/open-gsd/gsd-pi/issues/4541
     { id: "claude-code", label: "Claude Code CLI", category: "llm", authMode: "externalCli" },
+    { id: "cursor-agent", label: "Cursor Agent", category: "llm", envVar: "CURSOR_API_KEY", authMode: "externalCli" },
     { id: "openai", label: "OpenAI", category: "llm", envVar: "OPENAI_API_KEY", prefixes: ["sk-"], dashboardUrl: "platform.openai.com/api-keys" },
     { id: "github-copilot", label: "GitHub Copilot", category: "llm", envVar: "GITHUB_TOKEN", authMode: "browserOAuth" },
     { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex)", category: "llm", authMode: "browserOAuth" },

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

@@ -12,7 +12,7 @@ import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from "node:
 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, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
+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 { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
@@ -99,6 +99,12 @@ function meaningfulSection(value) {
         return "";
     return trimmed;
 }
+function renderGateFindings(gate) {
+    const findings = gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`;
+    if (gate.verdict !== "flag")
+        return findings;
+    return `> **Warning:** Verdict: flag - concerns recorded below\n\n${findings}`;
+}
 function pushIndented(lines, value, indent = "  ") {
     for (const line of value.split("\n")) {
         lines.push(`${indent}${line}`);
@@ -289,7 +295,7 @@ function renderTaskPlanMarkdown(task, taskGates = []) {
         if (gate && gate.verdict !== "omitted") {
             lines.push(`## ${label}`);
             lines.push("");
-            lines.push(gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`);
+            lines.push(renderGateFindings(gate));
             lines.push("");
         }
     }
@@ -319,14 +325,14 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
     if (q3 && q3.verdict !== "omitted") {
         lines.push("## Threat Surface");
         lines.push("");
-        lines.push(q3.findings.trim() || `- **Verdict:** ${q3.verdict}\n- **Rationale:** ${q3.rationale}`);
+        lines.push(renderGateFindings(q3));
         lines.push("");
     }
     const q4 = gates.find(g => g.gate_id === "Q4" && g.status === "complete");
     if (q4 && q4.verdict !== "omitted") {
         lines.push("## Requirement Impact");
         lines.push("");
-        lines.push(q4.findings.trim() || `- **Verdict:** ${q4.verdict}\n- **Rationale:** ${q4.rationale}`);
+        lines.push(renderGateFindings(q4));
         lines.push("");
     }
     const proofLevel = meaningfulSection(slice.proof_level);
@@ -701,6 +707,17 @@ export async function renderSliceSummary(basePath, milestoneId, sliceId) {
 export async function renderAllFromDb(basePath) {
     const result = { rendered: 0, skipped: 0, errors: [] };
     const milestones = getAllMilestones();
+    // Pre-fetch slices once per milestone and batch-load all tasks in one query
+    // family, avoiding an N+1 (previously one task query per slice).
+    const slicesByMilestone = new Map();
+    const slicePairs = [];
+    for (const milestone of milestones) {
+        const slices = getMilestoneSlices(milestone.id);
+        slicesByMilestone.set(milestone.id, slices);
+        for (const slice of slices)
+            slicePairs.push({ milestoneId: milestone.id, sliceId: slice.id });
+    }
+    const tasksBySlice = getTasksBySliceIds(slicePairs);
     for (const milestone of milestones) {
         // Render roadmap checkboxes
         try {
@@ -723,8 +740,8 @@ export async function renderAllFromDb(basePath) {
         catch (err) {
             result.errors.push(`milestone artifacts ${milestone.id}: ${err.message}`);
         }
-        // Iterate slices
-        const slices = getMilestoneSlices(milestone.id);
+        // Iterate slices (pre-fetched above)
+        const slices = slicesByMilestone.get(milestone.id) ?? [];
         for (const slice of slices) {
             // Preserve slice-scoped artifacts imported from disk, including real PLAN
             // fallback content when task rows cannot regenerate it.
@@ -760,8 +777,8 @@ export async function renderAllFromDb(basePath) {
             catch (err) {
                 result.errors.push(`slice summary ${milestone.id}/${slice.id}: ${err.message}`);
             }
-            // Iterate tasks
-            const tasks = getSliceTasks(milestone.id, slice.id);
+            // Iterate tasks (batched above)
+            const tasks = tasksBySlice.get(`${milestone.id}\0${slice.id}`) ?? [];
             for (const task of tasks) {
                 try {
                     const ok = await renderTaskSummary(basePath, milestone.id, slice.id, task.id);

package/dist/resources/extensions/gsd/migrate-external.js

@@ -8,7 +8,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
-import { externalGsdRoot, isInsideWorktree } from "./repo-identity.js";
+import { externalGsdRoot, externalStateAlreadyExistsForProject, isInsideWorktree } from "./repo-identity.js";
 import { getErrorMessage } from "./error-utils.js";
 import { hasGitTrackedGsdFiles } from "./gitignore.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -74,6 +74,15 @@ export function migrateToExternalState(basePath) {
             return { migrated: false };
         }
     }
+    // If external state already contains project data, this is not a legacy
+    // migration source. It is likely an already-migrated project whose symlink
+    // was replaced by a real directory, so copying would risk data loss.
+    if (externalStateAlreadyExistsForProject(basePath)) {
+        return {
+            migrated: false,
+            error: "External state already exists for this project; leaving local .gsd directory untouched to avoid overwriting authoritative state",
+        };
+    }
     const externalPath = externalGsdRoot(basePath);
     const migratingPath = join(basePath, ".gsd.migrating");
     try {
@@ -81,13 +90,13 @@ export function migrateToExternalState(basePath) {
         mkdirSync(externalPath, { recursive: true });
         // Rename .gsd -> .gsd.migrating (atomic lock).
         // On Windows, NTFS may reject rename with EPERM if file descriptors are
-        // open (VS Code watchers, antivirus on-access scan). Fall back to
-        // copy+delete (#1292).
+        // open (VS Code watchers, antivirus on-access scan). WSL/DrvFs can report
+        // the same transient lock as EACCES. Fall back to copy+delete (#1292).
         try {
             renameSync(localGsd, migratingPath);
         }
         catch (renameErr) {
-            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY") {
+            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY" || renameErr?.code === "EACCES") {
                 try {
                     cpSync(localGsd, migratingPath, { recursive: true, force: true });
                     rmSync(localGsd, { recursive: true, force: true });
@@ -239,7 +248,7 @@ function isLocalGsdExternalStateJunction(basePath, localGsd) {
  * Recover from a failed migration (`.gsd.migrating` exists).
  * Moves `.gsd.migrating` back to `.gsd` if `.gsd` doesn't exist, or removes an
  * orphaned staging directory when `.gsd` is already a verified external state
- * junction with intact current state.
+ * junction, or an intact real directory, with intact current state.
  */
 export function recoverFailedMigration(basePath) {
     const localGsd = join(basePath, ".gsd");
@@ -247,10 +256,18 @@ export function recoverFailedMigration(basePath) {
     if (!existsSync(migratingPath))
         return false;
     if (existsSync(localGsd)) {
-        if (!isLocalGsdExternalStateJunction(basePath, localGsd))
-            return false;
         if (!isCurrentGsdStateIntactForMigratingCleanup(basePath))
             return false;
+        if (!isLocalGsdExternalStateJunction(basePath, localGsd)) {
+            try {
+                const stat = lstatSync(localGsd);
+                if (!stat.isDirectory())
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
         try {
             rmSync(migratingPath, { recursive: true, force: true });
             return true;

package/dist/resources/extensions/gsd/milestone-merge-transaction.js

@@ -1,10 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Process-level transaction wrapper for milestone merge closeout.
 export function runMilestoneMergeTransaction(deps, input) {
-    return deps.mergeMilestoneToMain(input.basePath, input.milestoneId, input.roadmapContent);
+    return deps.mergeMilestone(input.basePath, input.milestoneId, input.roadmapContent);
 }
-export function createMilestoneMergeTransaction(mergeMilestoneToMain) {
+export function createMilestoneMergeTransaction(mergeMilestone) {
     return function mergeMilestoneTransaction(basePath, milestoneId, roadmapContent) {
-        return runMilestoneMergeTransaction({ mergeMilestoneToMain }, { basePath, milestoneId, roadmapContent });
+        return runMilestoneMergeTransaction({ mergeMilestone }, { basePath, milestoneId, roadmapContent });
     };
 }

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

@@ -1,4 +1,5 @@
-import { loadGlobalGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { crossAxisPreferenceWarnings } from "./preferences-validation.js";
 const notifiedPreferenceDiagnostics = new Set();
 export function collectPreferenceDiagnostics(basePath) {
     const diagnostics = [
@@ -14,6 +15,28 @@ export function collectPreferenceDiagnostics(basePath) {
         seen.add(signature);
         unique.push(diagnostic);
     }
+    const effective = loadEffectiveGSDPreferences(basePath);
+    if (effective) {
+        const existingMessages = new Set(unique.map((diagnostic) => diagnostic.message));
+        for (const message of crossAxisPreferenceWarnings(effective.preferences)) {
+            if (existingMessages.has(message))
+                continue;
+            const diagnostic = {
+                path: effective.path,
+                scope: effective.scope,
+                severity: "warning",
+                kind: "validation",
+                message,
+                sanitized: true,
+            };
+            const signature = preferenceDiagnosticSignature(diagnostic);
+            if (seen.has(signature))
+                continue;
+            seen.add(signature);
+            existingMessages.add(message);
+            unique.push(diagnostic);
+        }
+    }
     return unique;
 }
 export function formatPreferenceDiagnostic(diagnostic) {

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

@@ -74,10 +74,12 @@ function resolveWinningPhase(models, chain) {
  * - Legacy: `planning: claude-opus-4-6`
  * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
  */
-export function resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId) {
-    const loadOpts = availableModelIds !== undefined || preferredModelId !== undefined
-        ? { availableModelIds, preferredModelId }
-        : undefined;
+export function resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, skipProfileDefaults = false) {
+    const loadOpts = {
+        ...(availableModelIds !== undefined ? { availableModelIds } : {}),
+        ...(preferredModelId !== undefined ? { preferredModelId } : {}),
+        ...(skipProfileDefaults ? { skipProfileDefaults: true } : {}),
+    };
     const prefs = loadEffectiveGSDPreferences(basePath, loadOpts);
     const chain = phaseChainForUnit(unitType);
     if (!chain)