gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

package/dist/resources/extensions/gsd/safety/evidence-cross-ref.js

@@ -15,7 +15,7 @@
 export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
     const bashCalls = actualEvidence.filter((e) => e.kind === "bash");
     const mismatches = [];
-    for (const claimed of claimedEvidence) {
+    for (const claimed of latestClaimBatch(claimedEvidence)) {
         // Skip coerced entries — they're already flagged with exitCode: -1
         // and verdict: "unknown (coerced from string)" by db-tools.ts
         if (claimed.verdict?.includes("coerced from string"))
@@ -25,9 +25,11 @@ export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
         // Skip entries with empty or generic commands
         if (!claimed.command || claimed.command.length < 3)
             continue;
-        // Find matching bash call by command substring match
-        const match = findBestMatch(claimed.command, bashCalls);
-        if (!match) {
+        // Find matching bash calls by command similarity. A command may be retried
+        // after a failed first run; the newest matching execution is the one that
+        // supports or rejects a claimed pass.
+        const matches = findMatches(claimed.command, bashCalls);
+        if (matches.length === 0) {
             mismatches.push({
                 severity: "warning",
                 claimed,
@@ -37,6 +39,7 @@ export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
             continue;
         }
         // Exit code mismatch: LLM claims success but actual command failed
+        const match = latestMatch(matches);
         if (claimed.exitCode === 0 && match.exitCode !== 0) {
             mismatches.push({
                 severity: "error",
@@ -50,34 +53,55 @@ export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
 }
 // ─── Internals ──────────────────────────────────────────────────────────────
 /**
- * Find the best matching bash evidence entry for a claimed command.
+ * Verification evidence rows are append-only across retries, but a task
+ * completion inserts one batch at a single created_at timestamp. When that
+ * timestamp is present, safety should judge the newest completion claim only.
+ */
+function latestClaimBatch(claimedEvidence) {
+    const dated = claimedEvidence
+        .map((claim) => ({
+        claim,
+        time: typeof claim.createdAt === "string" ? Date.parse(claim.createdAt) : Number.NaN,
+    }))
+        .filter((entry) => Number.isFinite(entry.time));
+    if (dated.length === 0)
+        return claimedEvidence;
+    const latestTime = Math.max(...dated.map((entry) => entry.time));
+    return claimedEvidence.filter((claim) => (typeof claim.createdAt === "string" && Date.parse(claim.createdAt) === latestTime));
+}
+/**
+ * Find bash evidence entries matching a claimed command.
  * Uses substring matching — the claimed command may be a shortened version
  * of the actual command, or vice versa.
  */
-function findBestMatch(claimedCommand, bashCalls) {
+function findMatches(claimedCommand, bashCalls) {
     const normalized = claimedCommand.trim();
-    // Exact match first
-    const exact = bashCalls.find(b => b.command.trim() === normalized);
-    if (exact)
+    // Exact matches first
+    const exact = bashCalls.filter(b => b.command.trim() === normalized);
+    if (exact.length > 0)
         return exact;
     // Substring match: claimed is contained in actual or actual in claimed
-    const substring = bashCalls.find(b => b.command.includes(normalized) || normalized.includes(b.command));
-    if (substring)
+    const substring = bashCalls.filter(b => b.command.includes(normalized) || normalized.includes(b.command));
+    if (substring.length > 0)
         return substring;
     // Token match: split on whitespace and check significant overlap
     const claimedTokens = normalized.split(/\s+/).filter(t => t.length > 2);
     if (claimedTokens.length === 0)
-        return null;
-    let bestMatch = null;
-    let bestScore = 0;
+        return [];
+    const scoredMatches = [];
     for (const call of bashCalls) {
         const callTokens = new Set(call.command.split(/\s+/));
         const matchCount = claimedTokens.filter(t => callTokens.has(t)).length;
         const score = matchCount / claimedTokens.length;
-        if (score > bestScore && score >= 0.5) {
-            bestScore = score;
-            bestMatch = call;
+        if (score >= 0.5) {
+            scoredMatches.push({ call, score });
         }
     }
-    return bestMatch;
+    const bestScore = Math.max(0, ...scoredMatches.map((match) => match.score));
+    return scoredMatches
+        .filter((match) => match.score === bestScore)
+        .map((match) => match.call);
+}
+function latestMatch(matches) {
+    return matches.reduce((latest, match) => (match.timestamp > latest.timestamp ? match : latest));
 }

package/dist/resources/extensions/gsd/session-lock.js

@@ -18,8 +18,9 @@
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, readdirSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
-import { gsdRoot } from "./paths.js";
+import { gsdRoot, normalizeRealPath } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { markWorkerStoppingByPid } from "./db/auto-workers.js";
 const _require = createRequire(import.meta.url);
 // ─── Module State ───────────────────────────────────────────────────────────
 /** Release function from proper-lockfile — calling it releases the OS lock. */
@@ -225,6 +226,12 @@ export function acquireSessionLock(basePath) {
     mkdirSync(dirname(lp), { recursive: true });
     // Clean up numbered lock file variants from cloud sync conflicts (#1315)
     cleanupStrayLockFiles(basePath);
+    // If lock metadata points to a dead PID, mark that worker row stopping so
+    // crash diagnostics do not keep surfacing it as active.
+    const existingPreflight = readExistingLockData(lp);
+    if (existingPreflight?.pid && !isPidAlive(existingPreflight.pid)) {
+        markWorkerStoppingByPid(normalizeRealPath(basePath), existingPreflight.pid);
+    }
     // Write our lock data first (the content is informational; the OS lock is the real guard)
     const lockData = {
         pid: process.pid,
@@ -250,7 +257,10 @@ export function acquireSessionLock(basePath) {
     const lockDir = lockTarget + ".lock";
     if (existsSync(lockDir)) {
         const existingData = readExistingLockData(lp);
-        const isOrphan = !existingData || (existingData.pid && !isPidAlive(existingData.pid));
+        const deadPid = existingData?.pid && !isPidAlive(existingData.pid) ? existingData.pid : null;
+        if (deadPid)
+            markWorkerStoppingByPid(normalizeRealPath(basePath), deadPid);
+        const isOrphan = !existingData || !!deadPid;
         if (isOrphan) {
             try {
                 rmSync(lockDir, { recursive: true, force: true });
@@ -288,6 +298,9 @@ export function acquireSessionLock(basePath) {
         // Check: if auto.lock is gone and no process is alive, the lock dir is stale.
         const existingData = readExistingLockData(lp);
         const existingPid = existingData?.pid;
+        if (existingPid && !isPidAlive(existingPid)) {
+            markWorkerStoppingByPid(normalizeRealPath(basePath), existingPid);
+        }
         // If no lock file or no alive process, try to clean up and re-acquire (#1245)
         if (!existingData || (existingPid && !isPidAlive(existingPid))) {
             try {

package/dist/resources/extensions/gsd/slice-parallel-conflict.js

@@ -42,8 +42,8 @@ function extractFilePaths(content) {
  * @returns         true if parallel is unsafe (>5 shared files or missing plan).
  */
 export function hasFileConflict(basePath, mid, sliceA, sliceB) {
-    const planPathA = join(basePath, ".gsd", "milestones", mid, sliceA, "PLAN.md");
-    const planPathB = join(basePath, ".gsd", "milestones", mid, sliceB, "PLAN.md");
+    const planPathA = join(basePath, ".gsd", "milestones", mid, "slices", sliceA, `${sliceA}-PLAN.md`);
+    const planPathB = join(basePath, ".gsd", "milestones", mid, "slices", sliceB, `${sliceB}-PLAN.md`);
     // Conservative: missing PLAN = block
     if (!existsSync(planPathA) || !existsSync(planPathB)) {
         return true;

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

@@ -14,8 +14,8 @@
  */
 import { execFileSync, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { appendFileSync, existsSync, writeFileSync, readFileSync, mkdirSync, renameSync, unlinkSync, } from "node:fs";
-import { join, dirname } from "node:path";
+import { appendFileSync, existsSync, lstatSync, rmSync, writeFileSync, readFileSync, mkdirSync, renameSync, unlinkSync, } from "node:fs";
+import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
@@ -46,6 +46,44 @@ export function _buildSliceWorkerEnvForTest(basePath, milestoneId, sliceId, work
         GSD_SLICE_WORKER_TOKEN: workerToken,
     };
 }
+function isValidSliceWorktreePath(basePath, wtPath) {
+    if (!existsSync(wtPath))
+        return false;
+    const gitPath = join(wtPath, ".git");
+    if (!existsSync(gitPath))
+        return false;
+    try {
+        if (!lstatSync(gitPath).isFile())
+            return false;
+        const content = readFileSync(gitPath, "utf8").trim();
+        if (!content.startsWith("gitdir: "))
+            return false;
+        const rawGitdir = content.slice("gitdir: ".length).trim();
+        if (!rawGitdir)
+            return false;
+        const resolvedGitdir = isAbsolute(rawGitdir) ? rawGitdir : resolve(wtPath, rawGitdir);
+        const expectedPrefix = join(basePath, ".git", "worktrees").replaceAll("\\", "/");
+        const normalized = resolvedGitdir.replaceAll("\\", "/");
+        return normalized === expectedPrefix || normalized.startsWith(`${expectedPrefix}/`);
+    }
+    catch {
+        return false;
+    }
+}
+function isWorkerPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ESRCH")
+            return false;
+        return true;
+    }
+}
 function sliceStateFilePath(basePath) {
     return join(gsdRoot(basePath), SLICE_ORCHESTRATOR_STATE_FILE);
 }
@@ -242,8 +280,26 @@ export function restoreSliceState(basePath) {
  * crash followed by a fresh process is detectable. (Issue #4980 HIGH-8)
  */
 export function isSliceParallelActive(basePath) {
-    if (sliceState?.active === true)
-        return true;
+    const hasRunningWorkers = () => {
+        if (!sliceState)
+            return false;
+        for (const worker of sliceState.workers.values()) {
+            if (worker.state === "running") {
+                if (worker.process)
+                    return true;
+                if (isRecoveredSliceWorkerAlive(worker))
+                    return true;
+            }
+        }
+        return false;
+    };
+    if (sliceState?.active === true) {
+        if (hasRunningWorkers())
+            return true;
+        sliceState.active = false;
+        removeSliceStateFile(sliceState.basePath);
+        return false;
+    }
     if (!basePath)
         return false;
     const restored = restoreSliceState(basePath);
@@ -275,7 +331,11 @@ export function isSliceParallelActive(basePath) {
             cost: w.cost,
         });
     }
-    return true;
+    if (hasRunningWorkers())
+        return true;
+    sliceState.active = false;
+    removeSliceStateFile(sliceState.basePath);
+    return false;
 }
 /**
  * Get current slice orchestrator state (read-only snapshot).
@@ -318,6 +378,9 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
             const wtBranch = `slice/${milestoneId}/${slice.id}`;
             const wtName = `${milestoneId}-${slice.id}`;
             const wtPath = worktreePath(basePath, wtName);
+            if (existsSync(wtPath) && !isValidSliceWorktreePath(basePath, wtPath)) {
+                rmSync(wtPath, { recursive: true, force: true });
+            }
             if (!existsSync(wtPath)) {
                 createWorktree(basePath, wtName, { branch: wtBranch });
             }
@@ -361,6 +424,22 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
             catch { /* ignore cleanup failures */ }
         }
     }
+    // Guard: if workers died immediately, treat as failed start so callers
+    // don't exit auto-mode and re-dispatch in a rapid loop.
+    for (let i = started.length - 1; i >= 0; i--) {
+        const sid = started[i];
+        const worker = sliceState.workers.get(sid);
+        if (worker && isWorkerPidAlive(worker.pid))
+            continue;
+        started.splice(i, 1);
+        errors.push({ sid, error: "Worker exited immediately after spawn" });
+        sliceState.workers.delete(sid);
+        const wtName = `${milestoneId}-${sid}`;
+        try {
+            removeWorktree(basePath, wtName, { deleteBranch: true, force: true });
+        }
+        catch { /* ignore cleanup failures */ }
+    }
     // If nothing started, deactivate
     if (started.length === 0) {
         sliceState.active = false;

package/dist/resources/extensions/gsd/smart-entry-routing.js

@@ -0,0 +1,36 @@
+// GSD-2 — Smart entry routing decisions.
+// Pure route selection for /gsd guided wizard choices.
+export function resolveGuidedExecuteLaunchMode(isolationMode) {
+    return isolationMode === "worktree" ? "auto-step" : "guided-dispatch";
+}
+export function resolveActiveTaskChoiceRoute(input) {
+    if (input.choice === "auto") {
+        return {
+            kind: "auto-bootstrap",
+            verboseMode: false,
+        };
+    }
+    if (input.choice === "execute") {
+        if (resolveGuidedExecuteLaunchMode(input.isolationMode) === "auto-step") {
+            return {
+                kind: "auto-bootstrap",
+                verboseMode: false,
+                options: {
+                    step: true,
+                    milestoneLock: input.milestoneId,
+                },
+            };
+        }
+        return {
+            kind: "guided-dispatch",
+            unitType: "execute-task",
+        };
+    }
+    if (input.choice === "status") {
+        return { kind: "status" };
+    }
+    if (input.choice === "milestone_actions") {
+        return { kind: "milestone-actions" };
+    }
+    throw new Error(`Invalid ActiveTaskChoice: ${input.choice}`);
+}

package/dist/resources/extensions/gsd/state-reconciliation/drift/merge-state.js

@@ -10,6 +10,7 @@ import { isAbsolute, join, resolve } from "node:path";
 import { getErrorMessage } from "../../error-utils.js";
 import { nativeAddPaths, nativeCheckoutTheirs, nativeCommit, nativeConflictFiles, nativeMergeAbort, nativeRebaseAbort, nativeResetHard, } from "../../native-git-bridge.js";
 import { logError, logWarning } from "../../workflow-logger.js";
+import { isGsdWorktreePath } from "../../worktree-root.js";
 const SILENT_NOTIFY = () => { };
 function resolveGitDir(basePath) {
     try {
@@ -23,7 +24,11 @@ function resolveGitDir(basePath) {
         }
     }
     catch (err) {
-        logWarning("recovery", `gitdir resolution failed: ${getErrorMessage(err)}`);
+        const message = getErrorMessage(err);
+        logWarning("recovery", `gitdir resolution failed: ${message}`);
+        if (isGsdWorktreePath(basePath)) {
+            throw new Error(`Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${message.split("\n")[0]}). Repair or recreate the worktree before retrying.`);
+        }
     }
     return join(basePath, ".git");
 }

package/dist/resources/extensions/gsd/state-reconciliation/drift/project-md.js

@@ -1,12 +1,11 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 unregistered-milestone drift handler. Detects
 // milestones whose on-disk directory has meaningful content (ROADMAP/
-// CONTEXT/SUMMARY) but no DB row, then runs the markdown importer to
-// reconcile. PROJECT.md is the human-facing index — the importer's source
-// of truth is the .gsd/milestones/ directory tree.
+// CONTEXT/SUMMARY) but no DB row, then fails closed with an explicit recovery
+// instruction. Markdown hierarchy import is reserved for operator-controlled
+// migration/recovery commands, not automatic runtime reconciliation.
 import { existsSync } from "node:fs";
 import { getMilestone, isDbAvailable } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { resolveMilestoneFile } from "../../paths.js";
 function milestoneHasContent(basePath, milestoneId) {
@@ -31,17 +30,13 @@ export function detectUnregisteredMilestoneDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair: invoke the markdown importer. migrateHierarchyToDb walks the same
- * findMilestoneIds list the detector uses and INSERTs OR IGNOREs every
- * missing milestone (and its slices/tasks) — idempotent under cap=2 retry.
- *
- * Note: even though we receive one record at a time, the importer is a
- * project-wide operation. Repeated invocation across multiple drift records
- * in the same pass is wasteful but safe; a future optimization could
- * coalesce by checking whether the importer has already run this pass.
+ * Repair intentionally fails closed. The project-root DB is authoritative at
+ * runtime; markdown-only milestones must be imported through an explicit
+ * migration/recovery command so operators opt into changing canonical state.
  */
-export function repairUnregisteredMilestone(_record, ctx) {
-    migrateHierarchyToDb(ctx.basePath);
+export function repairUnregisteredMilestone(record, _ctx) {
+    throw new Error(`Milestone ${record.milestoneId} exists only as markdown projection. ` +
+        "Runtime reconciliation will not import markdown into the authoritative DB; run explicit GSD recovery/migration if this markdown should repopulate the database.");
 }
 export const unregisteredMilestoneHandler = {
     kind: "unregistered-milestone",

package/dist/resources/extensions/gsd/state-reconciliation/drift/roadmap.js

@@ -1,14 +1,15 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 roadmap-divergence drift handler. Detects mismatches
-// between ROADMAP.md (parsed slice sequence + depends declarations) and the
-// DB slice rows for that milestone, then reconciles via the markdown
-// importer plus an explicit junction-table sync.
+// between ROADMAP.md (parsed slice sequence, depends declarations, and
+// checkboxes) and the DB slice rows for that milestone, then re-renders the
+// ROADMAP projection from the authoritative DB rows.
 import { existsSync, readFileSync } from "node:fs";
-import { getMilestone, getMilestoneSlices, isDbAvailable, syncSliceDependencies, } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
+import { getMilestone, getMilestoneSlices, isDbAvailable, } from "../../gsd-db.js";
+import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
 import { resolveMilestoneFile } from "../../paths.js";
+import { isClosedStatus } from "../../status-guards.js";
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -30,8 +31,10 @@ function milestoneHasDivergence(basePath, milestoneId) {
     }
     const dbSlices = getMilestoneSlices(milestoneId);
     const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+    const roadmapSliceIds = new Set();
     for (let i = 0; i < roadmap.slices.length; i++) {
         const roadmapSlice = roadmap.slices[i];
+        roadmapSliceIds.add(roadmapSlice.id);
         const expectedSequence = i + 1;
         const dbSlice = dbSliceMap.get(roadmapSlice.id);
         if (!dbSlice)
@@ -40,6 +43,12 @@ function milestoneHasDivergence(basePath, milestoneId) {
             return true;
         if (!arraysEqual(dbSlice.depends, roadmapSlice.depends))
             return true;
+        if (isClosedStatus(dbSlice.status) !== roadmapSlice.done)
+            return true;
+    }
+    for (const dbSlice of dbSlices) {
+        if (!roadmapSliceIds.has(dbSlice.id))
+            return true;
     }
     return false;
 }
@@ -59,26 +68,12 @@ export function detectRoadmapDivergenceDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair a milestone's roadmap divergence:
- *   1. migrateHierarchyToDb upserts slice rows (sequence + depends JSON
- *      update via ON CONFLICT DO UPDATE).
- *   2. syncSliceDependencies updates the junction table per slice — the
- *      importer only writes the JSON column, not the relational view.
+ * Repair a milestone's roadmap divergence by regenerating the projection from
+ * DB rows. ROADMAP.md is a projection; runtime reconciliation must not import
+ * slice presence, sequence, dependencies, or checkbox state from markdown.
  */
-export function repairRoadmapDivergence(record, ctx) {
-    migrateHierarchyToDb(ctx.basePath);
-    const roadmapPath = resolveMilestoneFile(ctx.basePath, record.milestoneId, "ROADMAP");
-    if (!roadmapPath || !existsSync(roadmapPath))
-        return;
-    try {
-        const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
-        for (const slice of roadmap.slices) {
-            syncSliceDependencies(record.milestoneId, slice.id, slice.depends);
-        }
-    }
-    catch {
-        /* parse failure: detector will fire again next pass */
-    }
+export async function repairRoadmapDivergence(record, ctx) {
+    await renderRoadmapFromDb(ctx.basePath, record.milestoneId);
 }
 export const roadmapDivergenceHandler = {
     kind: "roadmap-divergence",

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

@@ -10,6 +10,7 @@ import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
 import { isClosedStatus, isDeferredStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
+import { autoHealSketchFlags } from './state-reconciliation/drift/sketch-flag.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
@@ -232,7 +233,7 @@ export async function deriveState(basePath, opts) {
     // from ROADMAP.md, PLAN.md, SUMMARY.md, REQUIREMENTS.md, or flag files.
     if (isDbAvailable()) {
         const stopDbTimer = debugTime("derive-state-db");
-        result = await deriveStateFromDb(basePath);
+        result = await deriveStateFromDb(basePath, opts?.projectRootForReads ?? basePath);
         stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
         _telemetry.dbDeriveCount++;
     }
@@ -352,6 +353,12 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
                 continue;
             }
             if (allSlicesDone) {
+                const validation = getLatestAssessmentByScope(m.id, "milestone-validation");
+                const verdict = typeof validation?.status === "string" ? validation.status : undefined;
+                if (verdict === "needs-attention") {
+                    registry.push({ id: m.id, title, status: "parked", ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+                    continue;
+                }
                 activeMilestone = { id: m.id, title };
                 activeMilestoneSlices = slices;
                 activeMilestoneFound = true;
@@ -460,7 +467,7 @@ async function handleAllSlicesDone(basePath, activeMilestone, registry, requirem
             recentDecisions: [],
             blockers: [
                 `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-                    `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+                    `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
             ],
             nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
             registry, requirements,
@@ -513,7 +520,7 @@ function checkReplanTrigger(basePath, milestoneId, sliceId) {
     const sliceRow = getSlice(milestoneId, sliceId);
     return !!sliceRow?.replan_triggered_at;
 }
-export async function deriveStateFromDb(basePath) {
+export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
     const requirements = getRequirementCounts();
     const allMilestones = getAllMilestones();
     const milestoneLock = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_MILESTONE_LOCK : undefined;
@@ -580,7 +587,17 @@ export async function deriveStateFromDb(basePath) {
             progress: { milestones: milestoneProgress, slices: sliceProgress },
         };
     }
-    const { activeSlice, activeSliceRow } = activeSliceContext;
+    const { activeSlice } = activeSliceContext;
+    let activeSliceRow = activeSliceContext.activeSliceRow;
+    // Heal stale sketch flags before honoring the DB-authoritative sketch gate.
+    // This recovers if PLAN.md exists but is_sketch was never flipped to 0.
+    if (activeMilestone?.id) {
+        autoHealSketchFlags(activeMilestone.id, (sid) => {
+            const planPath = resolveSliceFile(artifactReadRoot, activeMilestone.id, sid, "PLAN");
+            return planPath !== null && existsSync(planPath);
+        });
+        activeSliceRow = getSlice(activeMilestone.id, activeSlice.id);
+    }
     // ADR-011: DB slice metadata is authoritative for sketch refinement.
     // PLAN.md and preference flags are projections/configuration and are
     // deliberately not used to infer whether the slice itself is a sketch.
@@ -892,6 +909,10 @@ export async function _deriveStateImpl(basePath, opts) {
             const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
             const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
             const verdict = validationContent ? extractVerdict(validationContent) : undefined;
+            if (verdict === "needs-attention") {
+                registry.push({ id: mid, title, status: "parked" });
+                continue;
+            }
             // needs-remediation is terminal but requires re-validation (#3596)
             const needsRevalidation = !validationTerminal || verdict === 'needs-remediation';
             if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, cachedLoadFile)) {
@@ -911,7 +932,7 @@ export async function _deriveStateImpl(basePath, opts) {
                 registry.push({ id: mid, title, status: 'pending' });
             }
             else if (!activeMilestoneFound) {
-                // Terminal validation (pass/needs-attention) but no summary → completing-milestone
+                // Terminal passing validation but no summary → completing-milestone
                 activeMilestone = { id: mid, title };
                 activeRoadmap = roadmap;
                 activeMilestoneFound = true;
@@ -1132,7 +1153,7 @@ export async function _deriveStateImpl(basePath, opts) {
                 recentDecisions: [],
                 blockers: [
                     `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-                        `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+                        `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
                 ],
                 nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
                 registry,
@@ -1253,7 +1274,7 @@ export async function _deriveStateImpl(basePath, opts) {
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             t.done = true;
-            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
+            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
         }
     }
     const taskProgress = {

package/dist/resources/extensions/gsd/status-guards.js

@@ -2,14 +2,15 @@
  * Status predicates for GSD state-machine guards.
  *
  * The DB stores status as free-form strings. Three values indicate
- * "closed": "complete" (canonical), "done" (legacy / alias), and
+ * "closed": "complete" (canonical), "done" (legacy / alias),
+ * "closed" (legacy/imported), and
  * "skipped" (user-directed skip via rethink or backtrack).
  * Every inline `status === "complete" || status === "done"` should
  * use isClosedStatus() instead.
  */
 /** Returns true when a milestone, slice, or task status indicates closure. */
 export function isClosedStatus(status) {
-    return status === "complete" || status === "done" || status === "skipped";
+    return status === "complete" || status === "done" || status === "skipped" || status === "closed";
 }
 /** Returns true when a slice status indicates it was deferred by a decision. */
 export function isDeferredStatus(status) {
@@ -22,3 +23,14 @@ export function isDeferredStatus(status) {
 export function isInactiveStatus(status) {
     return isClosedStatus(status) || isDeferredStatus(status);
 }
+/** Returns true when a prior milestone should not block dispatch ordering. */
+export function isSkippedForDispatch(status) {
+    return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
+}
+/**
+ * Returns true when a milestone is future/backlog work (not currently executing).
+ * Includes legacy/project-specific alias "planned" for compatibility.
+ */
+export function isFutureMilestoneStatus(status) {
+    return status === "pending" || status === "queued" || status === "planned";
+}

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -69,6 +69,7 @@ parallel:
 verification_commands: []
 verification_auto_fix:
 verification_max_retries:
+per_unit_cost_cap_usd:
 notifications:
   enabled:
   on_complete:

package/dist/resources/extensions/gsd/templates/plan.md

@@ -99,11 +99,11 @@
   - "Improve UI"
 
   Each task should usually include:
-  - Why: why this task exists / what part of the slice it closes
-  - Files: the main files likely touched
-  - Do: concrete implementation steps and important constraints
-  - Verify: the command, test, or runtime check that proves it worked
-  - Done when: a measurable acceptance condition
+  - description: why this task exists, concrete steps, and done-when acceptance
+  - files: JSON array of likely touched paths
+  - verify: the command, test, or runtime check that proves it worked
+  - inputs: JSON array of existing paths or prior task outputs this task consumes
+  - expectedOutput: JSON array of paths this task creates or overwrites
 
   Keep the checkbox line format exactly:
   - [ ] **T01: Title** `est:30m`
@@ -131,10 +131,14 @@
 
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
+  - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
+  - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
+  - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
+  - GOOD: `python3 -m pytest tests/ -q --tb=short`
   - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
 
   Integration closure rule: