gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -4,10 +4,10 @@ import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, insertAssessment, transaction } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
-import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relTaskFile, relSliceFile, buildMilestoneFileName, buildTaskFileName, gsdProjectionRoot, } from "./paths.js";
 import { parseRoadmap } from "./parsers-legacy.js";
 import { validateArtifact } from "./schemas/validate.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
@@ -26,6 +26,9 @@ import { isWorkflowPrefsCaptured, resolveDeepProjectSetupState, } from "./deep-p
 import { annotateBackgroundable } from "./delegation-policy.js";
 import { invalidateAllCaches } from "./cache.js";
 import { insertMilestoneValidationGates } from "./milestone-validation-gates.js";
+import { nativeHasChanges } from "./native-git-bridge.js";
+import { debugLog, isDebugEnabled } from "./debug-logger.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 let reassessmentChecker = checkNeedsReassessment;
 let researchProjectPromptBuilder = buildResearchProjectPrompt;
 function shouldBypassMilestoneDepthGateInAuto(prefs) {
@@ -95,6 +98,14 @@ export function shouldRunDeepProjectSetup(state, prefs, basePath, options = {})
     }
     return hasPendingDeepStage(prefs, basePath);
 }
+function resolveArtifactBasePath(basePath, mid, session) {
+    if (session?.basePath &&
+        session.currentMilestoneId === mid &&
+        existsSync(session.basePath)) {
+        return session.basePath;
+    }
+    return resolveCanonicalMilestoneRoot(basePath, mid);
+}
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -102,6 +113,39 @@ function missingSliceStop(mid, phase) {
         level: "error",
     };
 }
+function isRegistryMilestoneComplete(state, mid) {
+    return state.registry.some((milestone) => milestone.id === mid && milestone.status === "complete");
+}
+function hasMilestonePassedDiscuss(basePath, mid) {
+    if (isDbAvailable()) {
+        try {
+            const slices = getMilestoneSlices(mid);
+            for (const slice of slices) {
+                const planPath = resolveSliceFile(basePath, mid, slice.id, "PLAN");
+                if (planPath && existsSync(planPath))
+                    return true;
+            }
+        }
+        catch (err) {
+            // Fall through to filesystem checks when DB access is degraded.
+            logWarning("dispatch", `discuss-progress DB check failed for ${mid}, falling back to filesystem: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const milestonePath = resolveMilestonePath(basePath, mid);
+    if (milestonePath) {
+        const slicesDir = join(milestonePath, "slices");
+        if (existsSync(slicesDir)) {
+            for (const sliceEntry of readdirSync(slicesDir, { withFileTypes: true })) {
+                if (!sliceEntry.isDirectory())
+                    continue;
+                const planPath = join(slicesDir, sliceEntry.name, `${sliceEntry.name}-PLAN.md`);
+                if (existsSync(planPath))
+                    return true;
+            }
+        }
+    }
+    return hasImplementationArtifacts(basePath, mid) === "present";
+}
 /**
  * Check for milestone slices missing SUMMARY files.
  * Returns array of missing slice IDs, or empty array if all present or DB unavailable.
@@ -247,6 +291,10 @@ export const DISPATCH_RULES = [
                 return null;
             if (!MILESTONE_ID_RE.test(mid))
                 return null;
+            if (isRegistryMilestoneComplete(state, mid))
+                return null;
+            if (hasMilestonePassedDiscuss(basePath, mid))
+                return null;
             // Align with the plan-v2 gate's lookup semantics: whitespace-only counts
             // as missing, and an auto worktree may fall back to GSD_PROJECT_ROOT.
             if (hasFinalizedMilestoneContext(basePath, mid))
@@ -294,9 +342,7 @@ export const DISPATCH_RULES = [
             const attempts = incrementUatCount(basePath, mid, sliceId);
             if (attempts > MAX_UAT_ATTEMPTS) {
                 return {
-                    action: "stop",
-                    reason: `run-uat for ${mid}/${sliceId} has been dispatched ${attempts - 1} times without producing a verdict. Verification commands may be broken — fix the UAT spec or manually write an ASSESSMENT verdict.`,
-                    level: "warning",
+                    action: "skip",
                 };
             }
             const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
@@ -339,11 +385,10 @@ export const DISPATCH_RULES = [
                     continue;
                 const { verdict, uatType } = result;
                 if (!isAcceptableUatVerdict(verdict, uatType)) {
-                    return {
-                        action: "stop",
-                        reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
-                        level: "warning",
-                    };
+                    // Do not hard-stop auto-mode on non-PASS verdicts. Allow progression
+                    // so follow-up slices can remediate, while complete-milestone still
+                    // enforces manual UAT PASS sign-off before closure.
+                    continue;
                 }
             }
             return null;
@@ -557,6 +602,8 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
             if (state.phase !== "pre-planning")
                 return null;
+            if (isRegistryMilestoneComplete(state, mid))
+                return null;
             const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
@@ -609,7 +656,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "planning (require_slice_discussion) → pause for discussion (#3454)",
+        name: "planning (require_slice_discussion) → pause for discussion",
         match: async ({ state, mid, basePath, prefs }) => {
             if (state.phase !== "planning")
                 return null;
@@ -945,7 +992,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task (recover missing task plan → plan-slice)",
-        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry, sessionProvider }) => {
+        match: async ({ state, mid, midTitle, basePath, session, sessionContextWindow, modelRegistry, sessionProvider }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -953,13 +1000,35 @@ export const DISPATCH_RULES = [
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
             const tid = state.activeTask.id;
+            const artifactBasePath = resolveArtifactBasePath(basePath, mid, session);
             // Guard: if the slice plan exists but the individual task plan files are
             // missing, the planner created S##-PLAN.md with task entries but never
             // wrote the tasks/ directory files. Dispatch plan-slice to regenerate
             // them rather than hard-stopping — fixes the infinite-loop described in
             // issue #909.
-            const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
-            if (!taskPlanPath || !existsSync(taskPlanPath)) {
+            const taskPlanPath = resolveTaskFile(artifactBasePath, mid, sid, tid, "PLAN");
+            const projectionTaskPlanPath = join(gsdProjectionRoot(artifactBasePath), "milestones", mid, "slices", sid, "tasks", buildTaskFileName(tid, "PLAN"));
+            if ((!taskPlanPath || !existsSync(taskPlanPath)) && !existsSync(projectionTaskPlanPath)) {
+                if (isDebugEnabled()) {
+                    const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
+                    const originalProjectRoot = session?.originalBasePath || basePath;
+                    const activeMilestoneWorktreePath = session?.basePath || basePath;
+                    const expectedTaskPlanExists = existsSync(expectedTaskPlanPath);
+                    debugLog("dispatch-missing-task-plan-recovery", {
+                        selectedDispatchRule: "executing → execute-task (recover missing task plan → plan-slice)",
+                        basePathUsedForArtifactChecks: artifactBasePath,
+                        milestoneRoot: artifactBasePath,
+                        originalProjectRoot,
+                        activeMilestoneWorktreePath,
+                        hasRootWorktreeMismatch: originalProjectRoot !== activeMilestoneWorktreePath,
+                        expectedTaskPlanPath,
+                        projectionTaskPlanPath,
+                        expectedTaskPlanExists,
+                        // Retained for compatibility with existing diagnostic parsers.
+                        artifactExists: expectedTaskPlanExists,
+                        projectionArtifactExists: existsSync(projectionTaskPlanPath),
+                    });
+                }
                 return {
                     action: "dispatch",
                     unitType: "plan-slice",
@@ -1016,7 +1085,7 @@ export const DISPATCH_RULES = [
                         mkdirSync(mDir, { recursive: true });
                     const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
                     const skipSource = trivialVariant
-                        ? "trivial-scope pipeline variant (#4781)"
+                        ? "trivial-scope pipeline variant"
                         : "`skip_milestone_validation` preference";
                     const skipValidationReason = trivialVariant ? "trivial-scope" : "preference";
                     const content = [
@@ -1078,7 +1147,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "completing-milestone → complete-milestone",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (state.phase !== "completing-milestone")
                 return null;
             // Defense-in-depth (#4324): skip dispatch if the DB already marks
@@ -1091,19 +1160,68 @@ export const DISPATCH_RULES = [
                     return { action: "skip" };
                 }
             }
-            // Safety guard (#2675): block completion when VALIDATION verdict is
-            // needs-remediation. The state machine treats needs-remediation as
-            // terminal (to prevent validate-milestone loops per #832), but
-            // completing-milestone should NOT proceed — remediation work is needed.
+            // Safety guard (#6132): refuse closure with uncommitted git changes.
+            if (nativeHasChanges(basePath)) {
+                return {
+                    action: "stop",
+                    reason: "Cannot complete milestone: uncommitted changes detected. Commit or stash before closing.",
+                    level: "warning",
+                };
+            }
+            // Safety guard (#6132): when UAT dispatch is enabled, enforce a PASS
+            // verdict for each closed slice before milestone closure.
+            if (prefs?.uat_dispatch) {
+                let closedSliceIds;
+                if (isDbAvailable()) {
+                    closedSliceIds = getMilestoneSlices(mid)
+                        .filter(s => isClosedStatus(s.status))
+                        .map(s => s.id);
+                }
+                else {
+                    const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
+                    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+                    if (!roadmapContent) {
+                        return {
+                            action: "stop",
+                            reason: `Cannot complete milestone ${mid}: unable to verify UAT verdicts because ROADMAP is unavailable while DB is not accessible.`,
+                            level: "warning",
+                        };
+                    }
+                    const roadmap = parseRoadmap(roadmapContent);
+                    closedSliceIds = roadmap.slices.filter(s => s.done).map(s => s.id);
+                }
+                for (const sliceId of closedSliceIds) {
+                    const result = await readUatGateVerdict(basePath, mid, sliceId);
+                    if (!result) {
+                        return {
+                            action: "stop",
+                            reason: `Cannot complete milestone ${mid}: missing UAT PASS verdict for ${sliceId}. Manual UAT sign-off (PASS) is required before milestone closure.`,
+                            level: "warning",
+                        };
+                    }
+                    const { verdict, uatType } = result;
+                    if (!isAcceptableUatVerdict(verdict, uatType)) {
+                        return {
+                            action: "stop",
+                            reason: `Cannot complete milestone ${mid}: UAT verdict for ${sliceId} is "${verdict}". Manual UAT sign-off (PASS) is required before milestone closure.`,
+                            level: "warning",
+                        };
+                    }
+                }
+            }
+            // Safety guard (#2675, #5747, #5920): block completion when VALIDATION
+            // verdict is anything other than pass. The state machine treats these
+            // verdicts as terminal, but completing-milestone should NOT proceed —
+            // remediation or human attention is needed.
             const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
             if (validationFile) {
                 const validationContent = await loadFile(validationFile);
                 if (validationContent) {
                     const verdict = extractVerdict(validationContent);
-                    if (verdict === "needs-remediation") {
+                    if (verdict !== "pass") {
                         return {
                             action: "stop",
-                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "needs-remediation". Address the remediation findings and re-run validation, or update the verdict manually.`,
+                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "${verdict}". Address the validation findings and re-run validation, or run \`/gsd verdict pass --rationale "..."\` to override.`,
                             level: "warning",
                         };
                     }
@@ -1118,16 +1236,12 @@ export const DISPATCH_RULES = [
                     level: "error",
                 };
             }
-            // Safety guard (#1703): verify the milestone produced implementation
-            // artifacts (non-.gsd/ files). A milestone with only plan files and
-            // zero implementation code should not be marked complete.
+            // Safety signal (#1703, #5097): detect milestones with only .gsd/
+            // artifacts. This no longer hard-blocks completion because some
+            // milestones are intentionally planning/documentation-only.
             const artifactCheck = hasImplementationArtifacts(basePath, mid);
             if (artifactCheck === "absent") {
-                return {
-                    action: "stop",
-                    reason: `Cannot complete milestone ${mid}: no implementation files found outside .gsd/. The milestone has only plan files — actual code changes are required.`,
-                    level: "error",
-                };
+                logWarning("dispatch", `Milestone ${mid} has no implementation files outside .gsd/ — continuing complete-milestone dispatch (planning-only/documentation-only milestone).`);
             }
             if (artifactCheck === "unknown") {
                 logWarning("dispatch", `Implementation artifact check inconclusive for ${mid} — proceeding (git context unavailable)`);

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -494,6 +494,8 @@ autoModeStartThinkingLevel) {
  * Handles formats: "provider/model", "bare-id", "org/model-name" (OpenRouter).
  */
 export function resolveModelId(modelId, availableModels, currentProvider) {
+    if (!modelId)
+        return undefined;
     const slashIdx = modelId.indexOf("/");
     if (slashIdx !== -1) {
         const maybeProvider = modelId.substring(0, slashIdx);