@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

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

@@ -0,0 +1,431 @@
+// Project/App: gsd-pi
+// File Purpose: Auto-mode artifact verification and worktree path fallbacks.
+import { parseUnitId } from "./unit-id.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
+import { clearParseCache } from "./files.js";
+import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGatesForTurn, } from "./gsd-db.js";
+import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
+import { isValidationTerminal } from "./state.js";
+import { getErrorMessage } from "./error-utils.js";
+import { logWarning, logError } from "./workflow-logger.js";
+import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relSliceFile, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { existsSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
+import { dirname, join, resolve } from "node:path";
+import { resolveExpectedArtifactPath, resolveExistingSliceResearchPath, } from "./auto-artifact-paths.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
+import { hasVerdict } from "./verdict-parser.js";
+import { validateArtifact } from "./schemas/validate.js";
+import { getProjectResearchStatus } from "./project-research-policy.js";
+import { isGsdWorktreePath } from "./worktree-root.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
+import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
+import { proveMilestoneCloseout } from "./milestone-closeout-proof.js";
+/**
+ * Optional override for the legacy roadmap parser used by verifyExpectedArtifact.
+ * Production leaves this null so the real parseLegacyRoadmap runs; tests inject
+ * a throwing function to deterministically exercise the parse-failure catches.
+ * @internal
+ */
+let _roadmapParserFn = null;
+/**
+ * Inject an override for the legacy roadmap parser, returning a function that
+ * restores the default (real parser) behavior. No production caller.
+ * @internal
+ */
+export function _setRoadmapParserFnForTests(fn) {
+    const previous = _roadmapParserFn;
+    _roadmapParserFn = fn;
+    return () => { _roadmapParserFn = previous; };
+}
+function parseRoadmapForRecovery(content) {
+    if (_roadmapParserFn)
+        return _roadmapParserFn(content);
+    return parseLegacyRoadmap(content);
+}
+/** Slice count for plan-milestone verification; shared by scoped and legacy paths. */
+export function countPlanMilestoneRoadmapSlices(content) {
+    return parseRoadmapForRecovery(content).slices.length;
+}
+export function diagnoseWorktreeIntegrityFailure(basePath) {
+    if (!isGsdWorktreePath(basePath))
+        return null;
+    if (!existsSync(basePath)) {
+        return `Worktree integrity failure: ${basePath} does not exist. Repair or recreate the worktree before retrying.`;
+    }
+    const gitPath = join(basePath, ".git");
+    if (!existsSync(gitPath)) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (.git missing). Repair or recreate the worktree before retrying.`;
+    }
+    try {
+        execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return null;
+    }
+    catch (err) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${getErrorMessage(err).split("\n")[0]}). Repair or recreate the worktree before retrying.`;
+    }
+}
+export function resolveArtifactVerificationBase(unitId, base) {
+    const { milestone } = parseUnitId(unitId);
+    if (!MILESTONE_ID_RE.test(milestone))
+        return base;
+    return resolveCanonicalMilestoneRoot(base, milestone);
+}
+function hasCapturedWorkflowPrefs(base) {
+    const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
+    if (!prefsPath || !existsSync(prefsPath))
+        return false;
+    const content = readFileSync(prefsPath, "utf-8");
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    return !!match && /^workflow_prefs_captured:\s*true\s*$/m.test(match[1]);
+}
+function hasValidResearchDecision(base) {
+    const decisionPath = resolveExpectedArtifactPath("research-decision", "RESEARCH-DECISION", base);
+    if (!decisionPath || !existsSync(decisionPath))
+        return false;
+    try {
+        const cfg = JSON.parse(readFileSync(decisionPath, "utf-8"));
+        return cfg.decision === "research" || cfg.decision === "skip";
+    }
+    catch {
+        return false;
+    }
+}
+function hasCompleteProjectResearch(base) {
+    return getProjectResearchStatus(base).complete;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasCheckedTaskCompletionOnDisk(base, mid, sid, tid) {
+    const slicePath = resolveSlicePath(base, mid, sid);
+    if (!slicePath)
+        return false;
+    const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
+    if (!planAbs || !existsSync(planAbs))
+        return false;
+    const planContent = readFileSync(planAbs, "utf-8");
+    const cbRe = new RegExp(`^\\s*-\\s+\\[[xX]\\]\\s+\\*\\*${escapeRegExp(tid)}(?:\\*\\*)?:`, "m");
+    return cbRe.test(planContent);
+}
+/**
+ * Check whether the expected artifact(s) for a unit exist on disk.
+ * Returns true if all required artifacts exist, or if the unit type has no
+ * single verifiable artifact (e.g., replan-slice).
+ */
+export function verifyExpectedArtifact(unitType, unitId, base) {
+    if (unitType.startsWith("hook/"))
+        return true;
+    clearPathCache();
+    clearParseCache();
+    if (unitType === "rewrite-docs") {
+        const overridesPath = resolveGsdRootFile(base, "OVERRIDES");
+        if (!existsSync(overridesPath))
+            return true;
+        const content = readFileSync(overridesPath, "utf-8");
+        return !content.includes("**Scope:** active");
+    }
+    if (unitType === "workflow-preferences") {
+        return hasCapturedWorkflowPrefs(base);
+    }
+    if (unitType === "triage-captures") {
+        const pending = loadPendingCaptures(base);
+        if (pending.length === 0)
+            return true;
+        logWarning("recovery", `verify-fail triage-captures ${unitId}: ${pending.length} pending capture(s) remain in CAPTURES.md`);
+        return false;
+    }
+    if (unitType === "quick-task") {
+        const { slice: captureId } = parseUnitId(unitId);
+        const capture = captureId ? loadAllCaptures(base).find((entry) => entry.id === captureId) : undefined;
+        if (capture?.executed === true)
+            return true;
+        logWarning("recovery", `verify-fail quick-task ${unitId}: capture ${captureId ?? "(missing capture id)"} not found or not marked executed`);
+        return false;
+    }
+    if (unitType === "discuss-project") {
+        const projectPath = resolveExpectedArtifactPath(unitType, unitId, base);
+        return !!projectPath && existsSync(projectPath) && validateArtifact(projectPath, "project").ok;
+    }
+    if (unitType === "discuss-requirements") {
+        const requirementsPath = resolveExpectedArtifactPath(unitType, unitId, base);
+        return !!requirementsPath && existsSync(requirementsPath) && validateArtifact(requirementsPath, "requirements").ok;
+    }
+    if (unitType === "research-decision") {
+        return hasValidResearchDecision(base);
+    }
+    if (unitType === "research-project") {
+        return hasCompleteProjectResearch(base);
+    }
+    if (unitType === "reactive-execute") {
+        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+        if (!mid || !sid || !batchPart)
+            return false;
+        const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
+        if (blockerPath && existsSync(blockerPath)) {
+            return true;
+        }
+        const slicePath = resolveSlicePath(base, mid, sid);
+        if (!slicePath)
+            return false;
+        const plusIdx = batchPart.indexOf("+");
+        if (plusIdx === -1) {
+            const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+            const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+            return summaryFiles.length > 0;
+        }
+        const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+        if (batchIds.length === 0)
+            return false;
+        const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+        const existingSummaries = new Set(resolveTaskFiles(tDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
+        for (const tid of batchIds) {
+            if (!existingSummaries.has(tid.toUpperCase()))
+                return false;
+        }
+        return true;
+    }
+    if (unitType === "gate-evaluate") {
+        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+        if (!mid || !sid || !batchPart)
+            return false;
+        const plusIdx = batchPart.indexOf("+");
+        if (plusIdx === -1)
+            return true;
+        const gateIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+        if (gateIds.length === 0)
+            return true;
+        try {
+            if (!isDbAvailable())
+                return false;
+            const pending = getPendingGatesForTurn(mid, sid, "gate-evaluate");
+            const pendingIds = new Set(pending.map((g) => g.gate_id));
+            for (const gid of gateIds) {
+                if (pendingIds.has(gid))
+                    return false;
+            }
+        }
+        catch (err) {
+            logWarning("recovery", `gate-evaluate DB check failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return true;
+    }
+    if (unitType === "research-slice" && unitId.endsWith("/parallel-research")) {
+        const { milestone: mid } = parseUnitId(unitId);
+        if (!mid)
+            return false;
+        const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
+        if (blockerPath && existsSync(blockerPath)) {
+            return true;
+        }
+        const roadmapFile = resolveExpectedArtifactPath("plan-milestone", mid, base);
+        if (!roadmapFile || !existsSync(roadmapFile)) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap missing`);
+            return false;
+        }
+        try {
+            const roadmap = parseRoadmapForRecovery(readFileSync(roadmapFile, "utf-8"));
+            const milestoneResearchFile = resolveExpectedArtifactPath("research-milestone", mid, base);
+            const hasMilestoneResearch = !!milestoneResearchFile && existsSync(milestoneResearchFile);
+            for (const slice of roadmap.slices) {
+                if (slice.done)
+                    continue;
+                if (hasMilestoneResearch && slice.id === "S01")
+                    continue;
+                const depsComplete = (slice.depends ?? []).every((depId) => {
+                    const summaryPath = resolveExpectedArtifactPath("complete-slice", `${mid}/${depId}`, base);
+                    return !!summaryPath && existsSync(summaryPath);
+                });
+                if (!depsComplete)
+                    continue;
+                if (!resolveExistingSliceResearchPath(base, mid, slice.id)) {
+                    logWarning("recovery", `verify-fail ${unitType} ${unitId}: slice ${slice.id} missing RESEARCH`);
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (err) {
+            logWarning("recovery", `parallel-research verification failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
+    const artifactBase = resolveArtifactVerificationBase(unitId, base);
+    let absPath = resolveExpectedArtifactPath(unitType, unitId, artifactBase);
+    if (!absPath || !existsSync(absPath)) {
+        const projectRoot = resolve(resolveWorktreeProjectRoot(artifactBase));
+        if (projectRoot && projectRoot !== artifactBase) {
+            const projectPath = resolveExpectedArtifactPath(unitType, unitId, projectRoot);
+            if (projectPath && existsSync(projectPath)) {
+                absPath = projectPath;
+            }
+        }
+    }
+    if (!absPath) {
+        logWarning("recovery", `verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null (no artifact contract registered for this unit type)`);
+        return false;
+    }
+    if (!existsSync(absPath)) {
+        const worktreeFailure = diagnoseWorktreeIntegrityFailure(artifactBase);
+        if (worktreeFailure) {
+            logError("recovery", `${worktreeFailure} Unit: ${unitType} ${unitId}.`);
+            return false;
+        }
+        logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
+        return false;
+    }
+    if (unitType === "validate-milestone") {
+        const validationContent = readFileSync(absPath, "utf-8");
+        if (!isValidationTerminal(validationContent)) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: validation not terminal (len=${validationContent.length}) at ${absPath}`);
+            return false;
+        }
+    }
+    if (unitType === "run-uat") {
+        const assessmentContent = readFileSync(absPath, "utf-8");
+        if (!hasVerdict(assessmentContent)) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: assessment missing verdict at ${absPath}`);
+            return false;
+        }
+    }
+    if (unitType === "plan-milestone") {
+        try {
+            if (countPlanMilestoneRoadmapSlices(readFileSync(absPath, "utf-8")) === 0) {
+                logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${absPath}`);
+                return false;
+            }
+        }
+        catch (err) {
+            logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
+    if (unitType === "plan-slice") {
+        const { milestone: mid, slice: sid } = parseUnitId(unitId);
+        if (mid && sid) {
+            try {
+                let taskIds = null;
+                let dbPrimary = false;
+                if (isDbAvailable()) {
+                    const refreshed = refreshWorkflowDatabaseFromDisk();
+                    if (refreshed) {
+                        const tasks = getSliceTasks(mid, sid);
+                        if (tasks.length > 0) {
+                            taskIds = tasks.map(t => t.id);
+                            dbPrimary = true;
+                        }
+                    }
+                }
+                if (!taskIds) {
+                    const planContent = readFileSync(absPath, "utf-8");
+                    const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+/m.test(planContent);
+                    const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+                    if (!hasCheckboxTask && !hasHeadingTask) {
+                        logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
+                        return false;
+                    }
+                    const plan = parseLegacyPlan(planContent);
+                    if (plan.tasks.length > 0)
+                        taskIds = plan.tasks.map((t) => t.id);
+                }
+                if (taskIds && taskIds.length > 0) {
+                    const tasksDir = join(dirname(absPath), "tasks");
+                    if (existsSync(tasksDir)) {
+                        for (const tid of taskIds) {
+                            const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
+                            const taskSummaryFile = join(tasksDir, `${tid}-SUMMARY.md`);
+                            if (!existsSync(taskPlanFile) && !existsSync(taskSummaryFile)) {
+                                logWarning("recovery", `verify-fail ${unitType} ${unitId}: task artifact missing for ${tid}`);
+                                return false;
+                            }
+                        }
+                    }
+                    else if (!dbPrimary && !absPath.replace(/\\/g, "/").includes(`.gsd/${LAYOUT_SEGMENTS.level1}`)) {
+                        logWarning("recovery", `verify-fail ${unitType} ${unitId}: tasks dir missing at ${tasksDir}`);
+                        return false;
+                    }
+                }
+            }
+            catch (err) {
+                logWarning("recovery", `plan-slice task plan verification failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    if (unitType === "execute-task") {
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+        if (mid && sid && tid) {
+            const dbTask = getTask(mid, sid, tid);
+            if (dbTask) {
+                if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
+                    return false;
+                }
+            }
+            else if (!isDbAvailable()) {
+                if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid))
+                    return false;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    if (unitType === "complete-slice") {
+        const { milestone: mid, slice: sid } = parseUnitId(unitId);
+        if (mid && sid) {
+            const uatPath = resolveSliceFile(base, mid, sid, "UAT")
+                ?? join(base, relSliceFile(base, mid, sid, "UAT"));
+            if (!existsSync(uatPath))
+                return false;
+            const dbSlice = getSlice(mid, sid);
+            if (dbSlice) {
+                if (dbSlice.status !== "complete")
+                    return false;
+            }
+            else if (!isDbAvailable()) {
+                const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+                if (roadmapFile && existsSync(roadmapFile)) {
+                    try {
+                        const roadmapContent = readFileSync(roadmapFile, "utf-8");
+                        const roadmap = parseRoadmapForRecovery(roadmapContent);
+                        const slice = roadmap.slices.find((s) => s.id === sid);
+                        if (slice && !slice.done)
+                            return false;
+                    }
+                    catch (e) {
+                        logWarning("recovery", `roadmap parse failed: ${e.message}`);
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    if (unitType === "complete-milestone") {
+        const { milestone: mid } = parseUnitId(unitId);
+        if (!mid)
+            return false;
+        const closeoutProof = proveMilestoneCloseout(mid, {
+            refreshFromDisk: true,
+            summaryArtifactBasePath: artifactBase,
+            implementationEvidence: {
+                basePath: base,
+                requirement: "not-absent",
+            },
+        });
+        if (!closeoutProof.ok) {
+            if (!isDbAvailable() && closeoutProof.reason === "db-unavailable") {
+                const summaryOutcome = classifyMilestoneSummaryContent(readFileSync(absPath, "utf-8"));
+                return summaryOutcome !== "failure" && hasImplementationArtifacts(base, mid) !== "absent";
+            }
+            return false;
+        }
+    }
+    return true;
+}

package/dist/resources/extensions/gsd/auto/session.js

@@ -78,6 +78,8 @@ export class AutoSession {
     currentUnitRouting = null;
     currentMilestoneId = null;
     sourceObservations = new SourceObservationStore();
+    /** Live tool-surface snapshot for dashboard / runtime telemetry while auto is active. */
+    toolSurfaceSnapshot = null;
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
     /** Explicit /gsd model pin captured at bootstrap (session-scoped policy override). */
@@ -122,6 +124,13 @@ export class AutoSession {
      * the issues after MAX_PRE_EXEC_RETRIES re-attempts.
      */
     preExecRetryCount = new Map();
+    /**
+     * Tracks how many times each slice unit has been re-dispatched to plan-slice
+     * because task plan files were missing. Keyed by unitId (e.g. "M001/S01").
+     * Separate from preExecRetryCount so pre-exec gate failures do not block or
+     * conflate with missing-task-plan recovery.
+     */
+    missingTaskPlanRetryCount = new Map();
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -270,6 +279,7 @@ export class AutoSession {
         this.unitRecoveryCount.clear();
         // Unit
         this.clearCurrentUnit();
+        this.toolSurfaceSnapshot = null;
         this.currentTraceId = null;
         this.currentTurnId = null;
         this.currentUnitRouting = null;
@@ -307,6 +317,7 @@ export class AutoSession {
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
         this.preExecRetryCount.clear();
+        this.missingTaskPlanRetryCount.clear();
         this.lastToolInvocationError = null;
         this.toolUnavailableRetries = 0;
         this.lastUnitAgentEndMessages = null;

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

@@ -25,7 +25,7 @@ export function decideVerificationRetry(input) {
         return { action: "pause", reason: "missing-retry-context" };
     }
     const key = verificationRetryKey(unitType, retryInfo.unitId);
-    const failureHash = hashVerificationFailureContext(retryInfo.failureContext);
+    const failureHash = hashVerificationFailureContext(retryInfo.signature ?? retryInfo.failureContext);
     if (input.previousFailureHash === failureHash) {
         return {
             action: "pause",

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -8,7 +8,8 @@
 import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
 import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { dirname, join } from "node:path";
+import { dirname, join, relative } from "node:path";
+import { existsSync } from "node:fs";
 function resolveMilestoneArtifactPath(base, mid, suffix) {
     const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
     if (existing)
@@ -281,3 +282,29 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             return null;
     }
 }
+/**
+ * Resolve slice RESEARCH with worktree projection first, then canonical
+ * project-root path. Shared by dispatch rules, execute-task prompts, and
+ * artifact verification.
+ */
+export function resolveSliceResearchLocation(basePath, mid, sid) {
+    const projectedFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
+    if (projectedFile) {
+        return {
+            absolutePath: projectedFile,
+            relativePath: relSliceFile(basePath, mid, sid, "RESEARCH"),
+        };
+    }
+    const canonicalPath = resolveExpectedArtifactPath("research-slice", `${mid}/${sid}`, basePath);
+    if (canonicalPath && existsSync(canonicalPath)) {
+        return {
+            absolutePath: canonicalPath,
+            relativePath: relative(basePath, canonicalPath),
+        };
+    }
+    return { absolutePath: null, relativePath: null };
+}
+/** Returns the absolute RESEARCH path when it exists, otherwise null. */
+export function resolveExistingSliceResearchPath(basePath, mid, sid) {
+    return resolveSliceResearchLocation(basePath, mid, sid).absolutePath;
+}

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

@@ -68,6 +68,10 @@ export function resolveCompactionThresholdPercent(raw) {
     const value = typeof raw === "number" && Number.isFinite(raw) && raw >= 0.5 && raw <= 0.95 ? raw : 0.6;
     return value <= 1 ? value * 100 : value;
 }
-export function shouldRerootStepSessionForContext(contextPercent, compactionThresholdPercent) {
+export const HARD_CONTEXT_REROOT_THRESHOLD_PERCENT = 90;
+export function shouldWarnStepSessionForContext(contextPercent, compactionThresholdPercent) {
     return getContextPauseAction(contextPercent, resolveCompactionThresholdPercent(compactionThresholdPercent)) === "pause";
 }
+export function shouldRerootStepSessionForContext(contextPercent) {
+    return getContextPauseAction(contextPercent, HARD_CONTEXT_REROOT_THRESHOLD_PERCENT) === "pause";
+}

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

@@ -40,7 +40,7 @@ import { detectWorktreeName } from "./worktree.js";
 import { probeGitConflictState } from "./git-conflict-state.js";
 import { runTurnGitAction } from "./git-service.js";
 import { parseUnitId } from "./unit-id.js";
-import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { resolveExpectedArtifactPath, resolveExistingSliceResearchPath } from "./auto-artifact-paths.js";
 import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
@@ -596,7 +596,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "uat-verdict-gate (non-PASS blocks progression)",
+        name: "uat-verdict-gate (non-PASS observed; closeout enforces)",
         match: async ({ mid, basePath, prefs }) => {
             // Only applies when UAT dispatch is enabled
             if (!prefs?.uat_dispatch)
@@ -611,9 +611,9 @@ export const DISPATCH_RULES = [
                     continue;
                 const { verdict, uatType } = result;
                 if (!isAcceptableUatVerdict(verdict, uatType)) {
-                    // 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.
+                    // Observe non-PASS verdicts without hard-stopping auto-mode. Allow
+                    // progression so follow-up slices can remediate, while
+                    // complete-milestone still enforces manual UAT PASS sign-off before closure.
                     continue;
                 }
             }
@@ -902,9 +902,19 @@ export const DISPATCH_RULES = [
             const sliceContextFile = resolveSliceFile(basePath, mid, state.activeSlice.id, "CONTEXT");
             if (sliceContextFile && existsSync(sliceContextFile))
                 return null; // discussion already done, proceed
+            const closedSliceIds = getClosedSliceIds(mid);
+            const justClosedSliceId = closedSliceIds[closedSliceIds.length - 1];
+            let priorVerdictWarning = "";
+            if (justClosedSliceId) {
+                const prior = await readUatGateVerdict(basePath, mid, justClosedSliceId);
+                if (prior && !isAcceptableUatVerdict(prior.verdict, prior.uatType)) {
+                    priorVerdictWarning =
+                        ` Note: the slice just closed (${justClosedSliceId}) recorded a non-PASS UAT verdict (${prior.verdict.toUpperCase()}); review before continuing.`;
+                }
+            }
             return {
                 action: "stop",
-                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.${priorVerdictWarning}`,
                 level: "warning",
             };
         },
@@ -939,7 +949,7 @@ export const DISPATCH_RULES = [
                 if (slice.done)
                     continue;
                 // Skip if already has research
-                if (resolveExistingExpectedArtifact("research-slice", `${mid}/${slice.id}`, basePath))
+                if (resolveExistingSliceResearchPath(basePath, mid, slice.id))
                     continue;
                 // Skip if dependencies aren't done (check for SUMMARY files)
                 const depsComplete = slice.depends.every((depId) => !!resolveExistingExpectedArtifact("complete-slice", `${mid}/${depId}`, basePath));
@@ -980,9 +990,7 @@ export const DISPATCH_RULES = [
                 return missingSliceStop(mid, state.phase);
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
-            const researchFile = resolveExistingExpectedArtifact("research-slice", `${mid}/${sid}`, basePath) ??
-                resolveSliceFile(basePath, mid, sid, "RESEARCH");
-            if (researchFile)
+            if (resolveExistingSliceResearchPath(basePath, mid, sid))
                 return null; // has research, fall through
             return {
                 action: "dispatch",
@@ -1240,6 +1248,7 @@ export const DISPATCH_RULES = [
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
             const tid = state.activeTask.id;
+            const unitId = `${mid}/${sid}`;
             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
@@ -1265,6 +1274,17 @@ export const DISPATCH_RULES = [
             if ((!taskPlanPath || !existsSync(taskPlanPath)) &&
                 !existsSync(projectionTaskPlanPath) &&
                 !tasksEmbeddedInSlicePlan) {
+                const MAX_MISSING_TASK_PLAN_RETRIES = 2;
+                const retryCount = session?.missingTaskPlanRetryCount?.get(unitId) ?? 0;
+                if (retryCount >= MAX_MISSING_TASK_PLAN_RETRIES) {
+                    session?.missingTaskPlanRetryCount?.delete(unitId);
+                    return {
+                        action: "stop",
+                        reason: `Missing task-plan recovery failed ${retryCount} times for ${unitId} - manual intervention required. Task plan ${tid} is still missing after regenerating the slice plan. Fix the task-plan files manually, then run /gsd auto to resume.`,
+                        level: "error",
+                    };
+                }
+                session?.missingTaskPlanRetryCount?.set(unitId, retryCount + 1);
                 if (isDebugEnabled()) {
                     const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
                     const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1288,10 +1308,11 @@ export const DISPATCH_RULES = [
                 return {
                     action: "dispatch",
                     unitType: "plan-slice",
-                    unitId: `${mid}/${sid}`,
+                    unitId,
                     prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, sessionProvider }),
                 };
             }
+            session?.missingTaskPlanRetryCount?.delete(unitId);
             return null;
         },
     },