@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

package/dist/resources/extensions/gsd/milestone-planning-persistence.js

@@ -0,0 +1,156 @@
+// Project/App: gsd-pi
+// File Purpose: Persist planned milestone roadmaps and their DB-backed projections.
+import { clearParseCache } from "./files.js";
+import { isClosedStatus } from "./status-guards.js";
+import { transaction, getMilestone, getMilestoneSlices, getSlice, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "./gsd-db.js";
+import { invalidateStateCache } from "./state.js";
+import { renderRoadmapFromDb } from "./markdown-renderer.js";
+import { renderAllProjections } from "./workflow-projections.js";
+import { writeManifest } from "./workflow-manifest.js";
+import { appendEvent } from "./workflow-events.js";
+import { logWarning } from "./workflow-logger.js";
+function validatePlanPromotion(params) {
+    const existingMilestone = getMilestone(params.milestoneId);
+    if (existingMilestone && isClosedStatus(existingMilestone.status)) {
+        return `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
+    }
+    // Guard: refuse to re-plan a milestone that would drop completed slices (#2960).
+    // Allow re-planning when all completed slices are still present in the
+    // incoming plan — their status is preserved below (#2558). Block only when
+    // the new plan omits a completed slice, which could shadow completed work.
+    const existingSlices = getMilestoneSlices(params.milestoneId);
+    const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
+    if (completedSlices.length > 0) {
+        const incomingSliceIds = new Set(params.slices.map(s => s.sliceId));
+        const droppedCompleted = completedSlices.filter(s => !incomingSliceIds.has(s.id));
+        if (droppedCompleted.length > 0) {
+            return `cannot re-plan milestone ${params.milestoneId}: ${droppedCompleted.length} completed slice(s) would be dropped (${droppedCompleted.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
+        }
+    }
+    // Validate depends_on: all dependencies must exist and be complete
+    if (params.dependsOn && params.dependsOn.length > 0) {
+        for (const depId of params.dependsOn) {
+            const dep = getMilestone(depId);
+            if (!dep) {
+                return `depends_on references unknown milestone: ${depId}`;
+            }
+            if (!isClosedStatus(dep.status)) {
+                return `depends_on milestone ${depId} is not yet complete (status: ${dep.status})`;
+            }
+        }
+    }
+    return null;
+}
+function writePlanRows(params) {
+    insertMilestone({
+        id: params.milestoneId,
+        title: params.title,
+        status: params.status ?? "active",
+        depends_on: params.dependsOn ?? [],
+    });
+    upsertMilestonePlanning(params.milestoneId, {
+        title: params.title,
+        status: params.status ?? "active",
+        depends_on: params.dependsOn ?? [],
+        vision: params.vision,
+        successCriteria: params.successCriteria,
+        keyRisks: params.keyRisks,
+        proofStrategy: params.proofStrategy,
+        verificationContract: params.verificationContract,
+        verificationIntegration: params.verificationIntegration,
+        verificationOperational: params.verificationOperational,
+        verificationUat: params.verificationUat,
+        definitionOfDone: params.definitionOfDone,
+        requirementCoverage: params.requirementCoverage,
+        boundaryMapMarkdown: params.boundaryMapMarkdown,
+    });
+    for (let i = 0; i < params.slices.length; i++) {
+        const slice = params.slices[i];
+        // Preserve completed/done status on re-plan (#2558).
+        // Without this, a re-plan after milestone transition would reset
+        // already-completed slices back to "pending".
+        const existing = getSlice(params.milestoneId, slice.sliceId);
+        const status = existing && (existing.status === "complete" || existing.status === "done")
+            ? existing.status
+            : "pending";
+        insertSlice({
+            id: slice.sliceId,
+            milestoneId: params.milestoneId,
+            title: slice.title,
+            status,
+            risk: slice.risk,
+            depends: slice.depends,
+            demo: slice.demo,
+            sequence: i + 1, // Preserve agent-ordered sequence (#3356)
+            // ADR-011: pass undefined through so ON CONFLICT preserves existing values
+            // when the caller omitted the fields on a re-plan.
+            isSketch: slice.isSketch,
+            sketchScope: slice.sketchScope,
+        });
+        upsertSlicePlanning(params.milestoneId, slice.sliceId, {
+            goal: slice.goal,
+            successCriteria: slice.successCriteria,
+            proofLevel: slice.proofLevel,
+            integrationClosure: slice.integrationClosure,
+            observabilityImpact: slice.observabilityImpact,
+        });
+    }
+}
+async function renderPlanArtifacts(basePath, params) {
+    try {
+        const renderResult = await renderRoadmapFromDb(basePath, params.milestoneId);
+        return renderResult.roadmapPath;
+    }
+    catch (renderErr) {
+        logWarning("tool", `plan_milestone — render failed (DB rows preserved for debugging): ${renderErr.message}`);
+        invalidateStateCache();
+        return { error: `render failed: ${renderErr.message}` };
+    }
+}
+async function runPostPlanHooks(basePath, params) {
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "plan-milestone",
+            params: { milestoneId: params.milestoneId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        logWarning("tool", `plan-milestone post-mutation hook warning: ${hookErr.message}`);
+    }
+}
+export async function persistMilestonePlan(params, basePath) {
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
+    // Guards must be inside the transaction so the state they check cannot
+    // change between the read and the write (#2723).
+    let guardError = null;
+    try {
+        transaction(() => {
+            guardError = validatePlanPromotion(params);
+            if (guardError)
+                return;
+            writePlanRows(params);
+        });
+    }
+    catch (err) {
+        return { error: `db write failed: ${err.message}` };
+    }
+    if (guardError) {
+        return { error: guardError };
+    }
+    const roadmapPath = await renderPlanArtifacts(basePath, params);
+    if (typeof roadmapPath !== "string")
+        return roadmapPath;
+    invalidateStateCache();
+    clearParseCache();
+    await runPostPlanHooks(basePath, params);
+    return {
+        milestoneId: params.milestoneId,
+        roadmapPath,
+    };
+}

package/dist/resources/extensions/gsd/milestone-readiness.js

@@ -0,0 +1,77 @@
+// Project/App: gsd-pi
+// File Purpose: Classify milestone readiness from DB status, slices, and artifacts.
+import { readFileSync } from "node:fs";
+import { getMilestone, getMilestoneSlices, isDbAvailable } from "./gsd-db.js";
+import { parseRoadmapSlices } from "./roadmap-slices.js";
+import { logWarning } from "./workflow-logger.js";
+export function classifyMilestoneReadiness(input) {
+    const hasContext = input.hasContext === true;
+    const hasDraftContext = !hasContext && input.hasDraftContext === true;
+    const hasSummary = input.hasSummary === true;
+    const sliceCount = input.sliceCount ?? 0;
+    const hasExecutablePlan = sliceCount > 0;
+    const status = input.status ?? null;
+    if (status === "complete" || hasSummary) {
+        return { kind: "terminal", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    if (status === "queued" && !hasContext && sliceCount === 0) {
+        return { kind: "queued-shell", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    if ((status === "needs-discussion" && !hasContext) || hasDraftContext) {
+        return { kind: "needs-discussion", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    if (hasExecutablePlan) {
+        return { kind: "executable-plan", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    return { kind: "planning-pending", hasContext, hasDraftContext, hasExecutablePlan };
+}
+export function readinessNeedsDiscussion(readiness) {
+    return readiness.kind === "needs-discussion" ||
+        (readiness.kind === "queued-shell" && readiness.hasDraftContext);
+}
+export function describeMilestoneReadinessPhase(phase) {
+    switch (phase) {
+        case "needs-discussion":
+            return {
+                label: "Discuss milestone draft",
+                description: "Milestone has a draft context — needs discussion before planning.",
+            };
+        case "pre-planning":
+            return {
+                label: "Research & plan milestone",
+                description: "Scout the landscape and create the roadmap.",
+            };
+        default:
+            return null;
+    }
+}
+function executablePlanSliceCount(milestoneId, roadmapFile) {
+    if (isDbAvailable()) {
+        return getMilestoneSlices(milestoneId).length;
+    }
+    if (!roadmapFile)
+        return 0;
+    try {
+        return parseRoadmapSlices(readFileSync(roadmapFile, "utf-8")).length;
+    }
+    catch (e) {
+        logWarning("guided", `failed to parse roadmap slices for ${milestoneId}: ${e.message}`);
+        return 0;
+    }
+}
+export function assessMilestoneHandoffReadiness(input) {
+    const milestone = isDbAvailable() ? getMilestone(input.milestoneId) : null;
+    return classifyMilestoneReadiness({
+        status: milestone?.status,
+        hasContext: input.contextFile != null,
+        sliceCount: executablePlanSliceCount(input.milestoneId, input.roadmapFile),
+    });
+}
+export function formatAcceptedDiscussHandoffMessage(milestoneId, readiness) {
+    if (readiness.hasExecutablePlan)
+        return `Milestone ${milestoneId} ready.`;
+    if (readiness.hasContext) {
+        return `Milestone ${milestoneId} context captured. Continuing the planning pipeline.`;
+    }
+    return `Milestone ${milestoneId} planning artifacts captured. Continuing the planning pipeline.`;
+}

package/dist/resources/extensions/gsd/milestone-settlement.js

@@ -0,0 +1,50 @@
+// Project/App: gsd-pi
+// File Purpose: Milestone closeout settlement state across DB proof, artifacts, merge, and cleanup.
+import { isInAutoWorktree } from "./auto-worktree.js";
+import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
+import { resolveCloseoutArtifactProjection } from "./artifact-projection.js";
+function isActiveUnmergedWorktree(input) {
+    if (!input.milestoneId || input.milestoneMerged)
+        return false;
+    return isInAutoWorktree(input.basePath);
+}
+export function evaluateAllCompleteSettlement(input) {
+    if (input.statePhase !== "complete") {
+        return { ok: true, reason: "not-applicable" };
+    }
+    if (!isActiveUnmergedWorktree(input)) {
+        return { ok: true, reason: "settled" };
+    }
+    const milestoneId = input.milestoneId;
+    if (!milestoneId) {
+        return { ok: true, reason: "settled" };
+    }
+    const projection = resolveCloseoutArtifactProjection({
+        milestoneId,
+        basePath: input.basePath,
+        originalBasePath: input.originalBasePath,
+    });
+    const proof = proveMilestoneCloseout(milestoneId, {
+        refreshFromDisk: true,
+        summaryArtifactBasePath: projection.summaryArtifactBasePath,
+    });
+    if (!proof.ok) {
+        return {
+            ok: false,
+            reason: "closeout-blocked",
+            action: "pause",
+            message: `${formatCloseoutProofBlock(proof)} The milestone branch has not been merged to main.`,
+            nextAction: `Resolve closeout blockers, then retry \`/gsd dispatch complete-milestone ${milestoneId}\`.`,
+            milestoneId,
+        };
+    }
+    return {
+        ok: false,
+        reason: "merge-pending",
+        action: "pause",
+        message: `Milestone ${milestoneId} is complete, but its worktree branch has not been merged to main. ` +
+            `Retry with \`/gsd dispatch complete-milestone ${milestoneId}\` or merge manually.`,
+        nextAction: `Retry \`/gsd dispatch complete-milestone ${milestoneId}\` or merge manually.`,
+        milestoneId,
+    };
+}

package/dist/resources/extensions/gsd/milestone-validation-evidence.js

@@ -0,0 +1,73 @@
+// Project/App: gsd-pi
+// File Purpose: Forwarded validation evidence rules for milestone validation.
+import { getArtifact, getMilestone, getMilestoneSlices } from "./gsd-db.js";
+import { loadFile } from "./files.js";
+import { resolveSliceFile } from "./paths.js";
+import { compactTextParts, hasBrowserEvidenceText, hasBrowserRequiredText, } from "./browser-evidence.js";
+export function hasRuntimeExecutableUatEvidenceText(text) {
+    if (!/\buatType:\s*runtime-executable\b/i.test(text))
+        return false;
+    if (!/\bverdict:\s*PASS\b/i.test(text))
+        return false;
+    return /^\|\s*[^|\n]+\s*\|\s*runtime\s*\|\s*PASS\s*\|[^|\n]*\bgsd_uat_exec\b/mi.test(text);
+}
+export async function browserEvidenceGateRequiresAttention(params, basePath) {
+    if (params.verdict !== "pass")
+        return false;
+    const milestone = getMilestone(params.milestoneId);
+    const slices = getMilestoneSlices(params.milestoneId);
+    const requirementText = compactTextParts([
+        milestone?.vision,
+        milestone?.success_criteria,
+        milestone?.verification_uat,
+        params.successCriteriaChecklist,
+        params.verificationClasses,
+        ...slices.flatMap((slice) => [
+            slice.demo,
+            slice.goal,
+            slice.success_criteria,
+        ]),
+    ]);
+    if (!hasBrowserRequiredText(requirementText))
+        return false;
+    const sliceEvidencePairs = [];
+    for (const slice of slices) {
+        const chunks = [];
+        const artifactPath = `milestones/${params.milestoneId}/slices/${slice.id}/${slice.id}-ASSESSMENT.md`;
+        const artifact = getArtifact(artifactPath);
+        if (artifact?.full_content)
+            chunks.push(artifact.full_content);
+        const assessmentPath = resolveSliceFile(basePath, params.milestoneId, slice.id, "ASSESSMENT");
+        const assessmentContent = assessmentPath ? await loadFile(assessmentPath) : null;
+        if (assessmentContent)
+            chunks.push(assessmentContent);
+        sliceEvidencePairs.push({
+            sliceRequirementText: compactTextParts([slice.demo, slice.goal, slice.success_criteria]),
+            evidenceText: chunks.join("\n\n"),
+        });
+    }
+    const browserRequiringSlices = sliceEvidencePairs.filter((slice) => hasBrowserRequiredText(slice.sliceRequirementText));
+    const runtimeBypasses = browserRequiringSlices.length > 0
+        ? browserRequiringSlices.every((slice) => hasRuntimeExecutableUatEvidenceText(slice.evidenceText))
+        : sliceEvidencePairs.some((slice) => hasRuntimeExecutableUatEvidenceText(slice.evidenceText));
+    if (runtimeBypasses)
+        return false;
+    const persistedEvidence = sliceEvidencePairs.map((slice) => slice.evidenceText).join("\n\n");
+    const validationEvidence = compactTextParts([
+        params.successCriteriaChecklist,
+        params.verificationClasses,
+        params.verdictRationale,
+        params.remediationPlan,
+    ]);
+    return !hasBrowserEvidenceText(`${persistedEvidence}\n\n${validationEvidence}`);
+}
+export function applyBrowserEvidenceGate(params) {
+    const note = "Browser evidence gate: Browser-observable acceptance criteria were detected, but no persisted ASSESSMENT or validation evidence recorded browser actions with assertions. Downgraded from pass to needs-attention.";
+    return {
+        ...params,
+        verdict: "needs-attention",
+        verdictRationale: params.verdictRationale.trim()
+            ? `${params.verdictRationale.trim()}\n\n${note}`
+            : note,
+    };
+}

package/dist/resources/extensions/gsd/milestone-validation-verdict.js

@@ -0,0 +1,57 @@
+// Project/App: gsd-pi
+// File Purpose: Resolve the authoritative milestone validation verdict across DB and disk projections.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { loadFile } from "./files.js";
+import { getLatestAssessmentByScope, isDbAvailable } from "./gsd-db.js";
+import { gsdProjectionRoot } from "./paths.js";
+import { extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+function verdictFromContent(content) {
+    if (!content)
+        return undefined;
+    const verdict = extractVerdict(content);
+    return verdict && isValidMilestoneVerdict(verdict) ? verdict : undefined;
+}
+function verdictFromDb(milestoneId) {
+    if (!isDbAvailable())
+        return undefined;
+    const assessment = getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    const status = typeof assessment?.status === "string" ? assessment.status : undefined;
+    return status && isValidMilestoneVerdict(status) ? status : undefined;
+}
+async function verdictFromValidationPath(path) {
+    if (!path || !existsSync(path))
+        return undefined;
+    return verdictFromContent(await loadFile(path));
+}
+/**
+ * Resolve the milestone validation verdict using the same authority order as
+ * DB-backed state derivation, with filesystem fallbacks that mirror
+ * `resolveExpectedArtifactPath` (canonical worktree projection, then project
+ * root). Manual `/gsd verdict` overrides persist to the DB first; a stale
+ * worktree-local VALIDATION.md must not re-block auto-mode after the override.
+ */
+export async function resolveMilestoneValidationVerdict(basePath, milestoneId) {
+    const dbVerdict = verdictFromDb(milestoneId);
+    if (dbVerdict)
+        return dbVerdict;
+    const canonicalBase = resolveCanonicalMilestoneRoot(basePath, milestoneId);
+    const canonicalPath = resolveExpectedArtifactPath("validate-milestone", milestoneId, canonicalBase);
+    const canonicalVerdict = await verdictFromValidationPath(canonicalPath);
+    if (canonicalVerdict)
+        return canonicalVerdict;
+    const projectRoot = resolveWorktreeProjectRoot(basePath);
+    if (projectRoot !== canonicalBase) {
+        const projectPath = resolveExpectedArtifactPath("validate-milestone", milestoneId, projectRoot);
+        const projectVerdict = await verdictFromValidationPath(projectPath);
+        if (projectVerdict)
+            return projectVerdict;
+    }
+    // Last resort: direct canonical projection path even when resolveDir helpers
+    // have not materialized the milestone directory yet.
+    const directPath = join(gsdProjectionRoot(canonicalBase), "milestones", milestoneId, `${milestoneId}-VALIDATION.md`);
+    return verdictFromValidationPath(directPath);
+}

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -11,6 +11,7 @@ import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { getErrorMessage } from "./error-utils.js";
 import { isInfrastructureError } from "./auto/infra-errors.js";
+import { debugCount } from "./debug-logger.js";
 // Issue #453: keep auto-mode bookkeeping on the stable git CLI path unless a
 // caller explicitly opts into the native helper.
 const NATIVE_GSD_GIT_ENABLED = process.env.GSD_ENABLE_NATIVE_GSD_GIT === "1";
@@ -40,6 +41,8 @@ function loadNative() {
 // ─── Fallback Helpers ──────────────────────────────────────────────────────
 /** Run a git command via execFileSync. Returns trimmed stdout. */
 function gitExec(basePath, args, allowFailure = false) {
+    // Counts git CLI shell-outs only (native libgit2 paths bypass this helper).
+    debugCount("gitInvocations");
     try {
         return execFileSync("git", args, {
             cwd: basePath,
@@ -64,6 +67,8 @@ function isRetryableGitError(err) {
     return code !== null && TRANSIENT_GIT_RETRY_CODES.has(code);
 }
 function execGitFileSyncWithRetry(basePath, args, options) {
+    // Counts git CLI shell-outs only (native libgit2 paths bypass this helper).
+    debugCount("gitInvocations");
     try {
         return execFileSync("git", args, {
             cwd: basePath,
@@ -77,6 +82,8 @@ function execGitFileSyncWithRetry(basePath, args, options) {
         if (!isRetryableGitError(err))
             throw err;
         sleepSync(GIT_RETRY_DELAY_MS);
+        // Retry is a second physical shell-out — count it too.
+        debugCount("gitInvocations");
         return execFileSync("git", args, {
             cwd: basePath,
             stdio: ["ignore", "pipe", "pipe"],
@@ -88,6 +95,8 @@ function execGitFileSyncWithRetry(basePath, args, options) {
 }
 /** Run a git command via execFileSync. Returns trimmed stdout. */
 function gitFileExec(basePath, args, allowFailure = false) {
+    // Counts git CLI shell-outs only (native libgit2 paths bypass this helper).
+    debugCount("gitInvocations");
     try {
         return execFileSync("git", args, {
             cwd: basePath,
@@ -921,6 +930,42 @@ export function nativeMergeSquash(basePath, branch) {
         throw err;
     }
 }
+/**
+ * Regular (non-squash) merge a branch (stages changes, does NOT commit).
+ * Uses --no-ff to ensure a proper merge commit and --no-commit so the caller
+ * can supply a custom commit message via nativeCommit.
+ * Respects the user's global git merge.ff config; --no-ff is additive here.
+ */
+export function nativeMergeRegular(basePath, branch) {
+    try {
+        execFileSync("git", ["merge", "--no-ff", "--no-commit", branch], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        });
+        return { success: true, conflicts: [] };
+    }
+    catch (err) {
+        const stderr = err instanceof Error ? err.stderr ?? err.message : String(err);
+        if (stderr.includes("local changes would be overwritten") ||
+            stderr.includes("not possible because you have unmerged files") ||
+            stderr.includes("overwritten by merge")) {
+            const dirtyFiles = stderr
+                .split("\n")
+                .filter((line) => line.startsWith("\t"))
+                .map((line) => line.trim())
+                .filter(Boolean);
+            return { success: false, conflicts: ["__dirty_working_tree__"], dirtyFiles };
+        }
+        const conflictOutput = gitExec(basePath, ["diff", "--name-only", "--diff-filter=U"], true);
+        const conflicts = conflictOutput ? conflictOutput.split("\n").filter(Boolean) : [];
+        if (conflicts.length > 0) {
+            return { success: false, conflicts };
+        }
+        throw err;
+    }
+}
 /**
  * Abort an in-progress merge.
  * Native: libgit2 reset + cleanup.

package/dist/resources/extensions/gsd/parallel-eligibility.js

@@ -4,11 +4,10 @@
  * Analyzes which milestones can safely run in parallel by checking
  * dependency satisfaction and file overlap across slice plans.
  */
-import { existsSync } from "node:fs";
 import { deriveState } from "./state.js";
-import { resolveGsdPathContract } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks, openDatabase } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { openExistingWorkflowDatabase } from "./db-workspace.js";
 // ─── File Collection ─────────────────────────────────────────────────────────
 /**
  * Collect all `filesLikelyTouched` across every slice plan in a milestone.
@@ -64,9 +63,7 @@ function detectFileOverlaps(fileSets) {
  */
 export async function analyzeParallelEligibility(basePath) {
     if (!isDbAvailable()) {
-        const { projectDb } = resolveGsdPathContract(basePath);
-        if (existsSync(projectDb))
-            openDatabase(projectDb);
+        openExistingWorkflowDatabase(basePath);
     }
     const milestoneIds = findMilestoneIds(basePath);
     const state = await deriveState(basePath);

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -12,9 +12,10 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath } from "./worktree-manager.js";
-import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe, runWorktreePostCreateHook, syncGsdStateToWorktree } from "./auto-worktree.js";
+import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe, runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
 import { nativeBranchExists } from "./native-git-bridge.js";
 import { readIntegrationBranch } from "./git-service.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { resolveParallelConfig } from "./preferences.js";
 import { writeSessionStatus, readAllSessionStatuses, readSessionStatus, removeSessionStatus, sendSignal, cleanupStaleSessions, } from "./session-status-io.js";
 import { analyzeParallelEligibility, } from "./parallel-eligibility.js";
@@ -448,7 +449,7 @@ export function _createMilestoneWorktree(basePath, milestoneId) {
     // Copy .gsd/ planning artifacts (milestones, CONTEXT, ROADMAP, etc.) from the
     // project root into the worktree. Without this, workers for newly-planned
     // milestones can't find their roadmap and exit immediately (#2184 Bug 4).
-    syncGsdStateToWorktree(basePath, info.path);
+    syncGsdStateToWorktreeByScope(scopeMilestone(createWorkspace(basePath), milestoneId), scopeMilestone(createWorkspace(info.path), milestoneId));
     return info.path;
 }
 // ─── Worker Spawning ───────────────────────────────────────────────────

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

@@ -0,0 +1,67 @@
+import { loadGlobalGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+const notifiedPreferenceDiagnostics = new Set();
+export function collectPreferenceDiagnostics(basePath) {
+    const diagnostics = [
+        ...(loadGlobalGSDPreferences()?.diagnostics ?? []),
+        ...(loadProjectGSDPreferences(basePath)?.diagnostics ?? []),
+    ];
+    const seen = new Set();
+    const unique = [];
+    for (const diagnostic of diagnostics) {
+        const signature = preferenceDiagnosticSignature(diagnostic);
+        if (seen.has(signature))
+            continue;
+        seen.add(signature);
+        unique.push(diagnostic);
+    }
+    return unique;
+}
+export function formatPreferenceDiagnostic(diagnostic) {
+    const scope = diagnostic.scope === "global" ? "global" : "project";
+    const level = diagnostic.severity === "error" ? "error" : "warning";
+    const heading = diagnostic.kind === "parse"
+        ? `GSD ${scope} preferences ${level}: ${diagnostic.path} could not be parsed.`
+        : `GSD ${scope} preferences ${level}: ${diagnostic.path} contains invalid settings.`;
+    const detail = formatPreferenceDiagnosticDetail(diagnostic);
+    const impact = diagnostic.ignored
+        ? "Preferences from this file were ignored; auto-mode may be using defaults."
+        : "Invalid settings were ignored or sanitized; auto-mode may be using defaults for them.";
+    return `${heading}\n${detail}\n${impact}\nRun /gsd doctor for details.`;
+}
+export function formatPreferenceDiagnosticDetail(diagnostic) {
+    if (diagnostic.line !== undefined && diagnostic.column !== undefined) {
+        return `YAML error at line ${diagnostic.line}, column ${diagnostic.column}: ${diagnostic.message}`;
+    }
+    return diagnostic.message;
+}
+export function notifyPreferenceDiagnostics(ctx, basePath, options) {
+    let notified = 0;
+    for (const diagnostic of collectPreferenceDiagnostics(basePath)) {
+        const signature = preferenceDiagnosticNotificationSignature(diagnostic, options?.surface);
+        if (notifiedPreferenceDiagnostics.has(signature))
+            continue;
+        notifiedPreferenceDiagnostics.add(signature);
+        ctx.ui.notify(formatPreferenceDiagnostic(diagnostic), diagnostic.severity === "error" ? "error" : "warning");
+        notified++;
+    }
+    return notified;
+}
+export function _resetPreferenceDiagnosticNotificationsForTests() {
+    notifiedPreferenceDiagnostics.clear();
+}
+function preferenceDiagnosticSignature(diagnostic) {
+    return [
+        diagnostic.path,
+        diagnostic.scope,
+        diagnostic.severity,
+        diagnostic.kind,
+        diagnostic.message,
+        diagnostic.line ?? "",
+        diagnostic.column ?? "",
+        diagnostic.ignored === true ? "ignored" : "",
+        diagnostic.sanitized === true ? "sanitized" : "",
+    ].join("\u0000");
+}
+function preferenceDiagnosticNotificationSignature(diagnostic, surface = "default") {
+    return `${surface}\u0000${preferenceDiagnosticSignature(diagnostic)}`;
+}