@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

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

@@ -1,16 +1,14 @@
 // Project/App: gsd-pi
 // File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { gsdProjectionRoot, resolveSlicePath, resolveMilestoneFile } from "./paths.js";
+import { gsdProjectionRoot, resolveSlicePath } from "./paths.js";
+import { resolveMilestoneValidationVerdict } from "./milestone-validation-verdict.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getTask, getSliceTasks, getMilestoneSlices } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { extractVerdict } from "./verdict-parser.js";
 import { isClosedStatus } from "./status-guards.js";
 import { loadFile } from "./files.js";
-import { parseRoadmap } from "./parsers-legacy.js";
-import { isMilestoneComplete } from "./state.js";
 import { runVerificationGate, runVerificationGateForTargets, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
@@ -25,6 +23,7 @@ import { getSlice } from "./gsd-db.js";
 import { getLedger } from "./metrics.js";
 import { getUnitCostSpikeAction, resolveUnitCostSpikeMultiplier } from "./auto-budget.js";
 import { formatPostUnitStatusCard } from "./auto-status-message.js";
+import { detectWebApp } from "./web-app-uat.js";
 function getCurrentUnitCostStats(unitId) {
     const ledger = getLedger();
     if (!ledger || !Array.isArray(ledger.units) || ledger.units.length === 0) {
@@ -214,22 +213,22 @@ async function runValidateMilestonePostCheck(vctx, pauseAuto) {
     };
     const validationBasePath = resolveCanonicalMilestoneRoot(s.basePath, mid);
     const validationFile = join(gsdProjectionRoot(validationBasePath), "milestones", mid, `${mid}-VALIDATION.md`);
-    if (!validationFile) {
+    const validationContent = await loadFile(validationFile);
+    if (validationContent !== null && validationContent.trim() === "") {
         if (await reassessmentInvalidatedValidation()) {
             clearValidationRetry();
             return "continue";
         }
-        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. No VALIDATION.md was created.");
+        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. VALIDATION.md exists but is empty.");
     }
-    const validationContent = await loadFile(validationFile);
-    if (!validationContent) {
+    const verdict = await resolveMilestoneValidationVerdict(s.basePath, mid);
+    if (!verdict) {
         if (await reassessmentInvalidatedValidation()) {
             clearValidationRetry();
             return "continue";
         }
-        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. VALIDATION.md exists but is empty.");
+        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. No VALIDATION.md was created.");
     }
-    const verdict = extractVerdict(validationContent);
     if (verdict === "needs-attention") {
         ctx.ui.notify(`Milestone ${mid} validation returned verdict=needs-attention. Pausing for human review.`, "error");
         process.stderr.write([
@@ -274,32 +273,15 @@ async function runValidateMilestonePostCheck(vctx, pauseAuto) {
  * DB-backed projects are authoritative (#4094 peer review); falls back to
  * roadmap parsing only when the DB is unavailable.
  */
-async function countIncompleteSlices(basePath, milestoneId) {
-    if (isDbAvailable()) {
-        const slices = getMilestoneSlices(milestoneId);
-        if (slices.length === 0) {
-            // No DB rows — treat as "unknown", do not pause.
-            return 1;
-        }
-        return slices.filter((slice) => !isClosedStatus(slice.status)).length;
-    }
-    // Filesystem fallback: parse the roadmap markdown.
-    try {
-        const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-        if (!roadmapFile)
-            return 1;
-        const roadmapContent = await loadFile(roadmapFile);
-        if (!roadmapContent)
-            return 1;
-        const roadmap = parseRoadmap(roadmapContent);
-        if (roadmap.slices.length === 0)
-            return 1;
-        return isMilestoneComplete(roadmap) ? 0 : 1;
-    }
-    catch {
-        // Parsing failures should not cause false-positive pauses.
+async function countIncompleteSlices(_basePath, milestoneId) {
+    // DB-authoritative (ADR-017): no markdown fallback. DB unavailable or no
+    // rows means "unknown" — do not pause.
+    if (!isDbAvailable())
         return 1;
-    }
+    const slices = getMilestoneSlices(milestoneId);
+    if (slices.length === 0)
+        return 1;
+    return slices.filter((slice) => !isClosedStatus(slice.status)).length;
 }
 /**
  * Run the verification gate for the current execute-task unit.
@@ -636,14 +618,25 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
             s.pendingVerificationRetry = null;
             return "continue";
         }
+        else if (verdict.reason === "no-host-checks" &&
+            taskAlreadyComplete &&
+            detectWebApp(s.basePath) &&
+            !result.runtimeErrors?.some((e) => e.blocking)) {
+            s.verificationRetryCount.delete(retryKey);
+            s.verificationRetryFailureHashes.delete(retryKey);
+            s.pendingVerificationRetry = null;
+            ctx.ui.notify("No task-level host verification command was found for a completed browser-facing task; continuing so slice UAT can verify the UI with browser tools.", "warning");
+            return "continue";
+        }
         else if (verdict.reason === "no-host-checks") {
             s.verificationRetryCount.delete(retryKey);
             s.verificationRetryFailureHashes.delete(retryKey);
             s.pendingVerificationRetry = null;
-            ctx.ui.notify("Verification gate FAILED — no runnable host-owned verification checks were discovered. Pausing for human review.", "error");
+            const pauseMessage = `Verification failed: ${verdict.failureContext}`;
+            ctx.ui.notify(`Verification gate FAILED — ${verdict.failureContext}`, "error");
             process.stderr.write(`verification-gate: ${verdict.failureContext}\n`);
             await pauseAuto(ctx, pi, {
-                message: "Verification failed: no runnable host-owned verification checks were discovered.",
+                message: pauseMessage,
                 category: "unknown",
             });
             return "pause";

package/dist/resources/extensions/gsd/auto-worktree-repair.js

@@ -3,6 +3,7 @@
 import { existsSync, lstatSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { worktreePath } from "./worktree-manager.js";
+import { worktreesDirs } from "./worktree-placement.js";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 const defaultFs = {
     existsSync,
@@ -22,6 +23,13 @@ export function expectedAutoWorktreePath(projectRoot, milestoneId) {
         return null;
     return worktreePath(projectRoot, id);
 }
+/** Every path the milestone worktree may legitimately live at (canonical + legacy). */
+function candidateAutoWorktreePaths(projectRoot, milestoneId) {
+    const id = milestoneId?.trim();
+    if (!id || !isValidMilestoneId(id))
+        return [];
+    return worktreesDirs(projectRoot).map((dir) => join(dir, id));
+}
 export function resolvePausedAutoWorktreePath(input) {
     if (input.baseIsAutoWorktree)
         return input.basePath;
@@ -43,8 +51,8 @@ export function assessAutoWorktreeRepairTarget(input) {
     if (!expectedPath) {
         return { ok: false, reason: "missing expected worktree path" };
     }
-    const computedExpectedPath = expectedAutoWorktreePath(input.projectRoot, input.milestoneId);
-    if (!computedExpectedPath || !samePath(expectedPath, computedExpectedPath)) {
+    const candidatePaths = candidateAutoWorktreePaths(input.projectRoot, input.milestoneId);
+    if (candidatePaths.length === 0 || !candidatePaths.some((candidate) => samePath(expectedPath, candidate))) {
         return { ok: false, reason: "expected worktree path does not match milestone" };
     }
     if (!samePath(input.activeRoot, input.projectRoot) && !samePath(input.activeRoot, expectedPath)) {