@opengsd/gsd-pi 1.2.0-dev.b1abb545 → 1.2.0-dev.ddc97c10

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -7,12 +7,13 @@ import { getGateIdsForTurn } from "../gate-registry.js";
 import { transaction, getMilestone, getSlice, getSliceTasks, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, setSliceSketchFlag, deleteTask, deleteArtifactByPath, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
-import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
+import { runTaskPathChecks } from "../pre-execution-checks.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "../repository-registry.js";
@@ -193,11 +194,16 @@ function validateTaskPathsBeforePersist(params, basePath, defaultTargets, allowe
     const additionalRoots = allowedRoots
         .map((root) => resolve(root))
         .filter((root) => root !== baseRoot);
-    const context = additionalRoots.length > 0 ? { additionalRoots } : undefined;
-    const checks = [
-        ...checkFilePathConsistency(taskRows, basePath, context),
-        ...checkTaskOrdering(taskRows, basePath, context),
-    ];
+    const resolvedCanonicalRoot = resolve(resolveWorktreeProjectRoot(basePath));
+    const canonicalProjectRoot = resolvedCanonicalRoot !== baseRoot ? resolvedCanonicalRoot : undefined;
+    const hasContext = additionalRoots.length > 0 || canonicalProjectRoot !== undefined;
+    const context = hasContext
+        ? {
+            ...(additionalRoots.length > 0 ? { additionalRoots } : {}),
+            ...(canonicalProjectRoot !== undefined ? { canonicalProjectRoot } : {}),
+        }
+        : undefined;
+    const checks = runTaskPathChecks(taskRows, basePath, context);
     const blocking = checks.filter((check) => !check.passed && check.blocking);
     if (blocking.length === 0)
         return null;
@@ -361,7 +367,7 @@ export async function handlePlanSlice(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────────────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "plan-slice",

package/dist/resources/extensions/gsd/tools/plan-task.js

@@ -4,7 +4,7 @@ import { isNonEmptyString, validateStringArray } from "../validation.js";
 import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -110,7 +110,7 @@ export async function handlePlanTask(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────────────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "plan-task",

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -6,7 +6,7 @@ import { isNonEmptyString } from "../validation.js";
 import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteAssessmentByScope, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -234,7 +234,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "reassess-roadmap",

package/dist/resources/extensions/gsd/tools/reopen-milestone.js

@@ -7,10 +7,9 @@
  * artifacts so the DB-filesystem reconciler does not auto-correct
  * entities back to "complete".
  */
-import { getMilestone, getMilestoneSlices, getSliceTasks, reopenMilestoneStatus, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { getMilestoneSlices, getSliceTasks, reopenMilestoneCascade, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -23,35 +22,18 @@ export async function handleReopenMilestone(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    let guardError = null;
-    let slicesResetCount = 0;
-    let tasksResetCount = 0;
-    transaction(() => {
-        const milestone = getMilestone(params.milestoneId);
-        if (!milestone) {
-            guardError = `milestone not found: ${params.milestoneId}`;
-            return;
+    // ── Atomic reopen cascade (guards + writes in one transaction) ───────────
+    const outcome = reopenMilestoneCascade(params.milestoneId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "milestone-not-found":
+                return { error: `milestone not found: ${params.milestoneId}` };
+            case "milestone-not-closed":
+                return { error: `milestone ${params.milestoneId} is not closed (status: ${outcome.status}) — nothing to reopen` };
         }
-        if (!isClosedStatus(milestone.status)) {
-            guardError = `milestone ${params.milestoneId} is not closed (status: ${milestone.status}) — nothing to reopen`;
-            return;
-        }
-        reopenMilestoneStatus(params.milestoneId);
-        const slices = getMilestoneSlices(params.milestoneId);
-        slicesResetCount = slices.length;
-        for (const slice of slices) {
-            updateSliceStatus(params.milestoneId, slice.id, "in_progress");
-            const tasks = getSliceTasks(params.milestoneId, slice.id);
-            tasksResetCount += tasks.length;
-            for (const task of tasks) {
-                updateTaskStatus(params.milestoneId, slice.id, task.id, "pending");
-            }
-        }
-    });
-    if (guardError) {
-        return { error: guardError };
     }
+    const slicesResetCount = outcome.slicesReset;
+    const tasksResetCount = outcome.tasksReset;
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
     // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
@@ -92,7 +74,7 @@ export async function handleReopenMilestone(params, basePath) {
     clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
-        await renderAllProjections(basePath, params.milestoneId);
+        await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
         writeManifest(basePath);
         appendEvent(basePath, {
             cmd: "reopen-milestone",

package/dist/resources/extensions/gsd/tools/reopen-slice.js

@@ -9,10 +9,9 @@
  */
 // GSD — reopen-slice tool handler
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-import { getMilestone, getSlice, getSliceTasks, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { getSliceTasks, reopenSliceCascade, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -27,39 +26,21 @@ export async function handleReopenSlice(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    let guardError = null;
-    let tasksResetCount = 0;
-    transaction(() => {
-        const milestone = getMilestone(params.milestoneId);
-        if (!milestone) {
-            guardError = `milestone not found: ${params.milestoneId}`;
-            return;
+    // ── Atomic reopen cascade (guards + writes in one transaction) ───────────
+    const outcome = reopenSliceCascade(params.milestoneId, params.sliceId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "milestone-not-found":
+                return { error: `milestone not found: ${params.milestoneId}` };
+            case "milestone-closed":
+                return { error: `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${outcome.status})` };
+            case "slice-not-found":
+                return { error: `slice not found: ${params.milestoneId}/${params.sliceId}` };
+            case "slice-not-complete":
+                return { error: `slice ${params.sliceId} is not complete (status: ${outcome.status}) — nothing to reopen` };
         }
-        if (isClosedStatus(milestone.status)) {
-            guardError = `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
-            return;
-        }
-        const slice = getSlice(params.milestoneId, params.sliceId);
-        if (!slice) {
-            guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
-            return;
-        }
-        if (!isClosedStatus(slice.status)) {
-            guardError = `slice ${params.sliceId} is not complete (status: ${slice.status}) — nothing to reopen`;
-            return;
-        }
-        // Fetch tasks inside txn so the list is consistent with the slice status check
-        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-        tasksResetCount = tasks.length;
-        updateSliceStatus(params.milestoneId, params.sliceId, "in_progress");
-        for (const task of tasks) {
-            updateTaskStatus(params.milestoneId, params.sliceId, task.id, "pending");
-        }
-    });
-    if (guardError) {
-        return { error: guardError };
     }
+    const tasksResetCount = outcome.tasksReset;
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
     // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
@@ -91,7 +72,7 @@ export async function handleReopenSlice(params, basePath) {
     clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
-        await renderAllProjections(basePath, params.milestoneId);
+        await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
         writeManifest(basePath);
         appendEvent(basePath, {
             cmd: "reopen-slice",

package/dist/resources/extensions/gsd/tools/reopen-task.js

@@ -11,7 +11,7 @@
 import { getMilestone, getSlice, getTask, updateTaskStatus, transaction, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -83,7 +83,7 @@ export async function handleReopenTask(params, basePath) {
     clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
-        await renderAllProjections(basePath, params.milestoneId);
+        await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
         writeManifest(basePath);
         appendEvent(basePath, {
             cmd: "reopen-task",

package/dist/resources/extensions/gsd/tools/replan-slice.js

@@ -4,7 +4,7 @@ import { invalidateStateCache } from "../state.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
 import { renderPlanFromDb, renderReplanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -162,7 +162,7 @@ export async function handleReplanSlice(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "replan-slice",

package/dist/resources/extensions/gsd/tools/skip-slice.js

@@ -9,8 +9,7 @@
  * This function performs DB writes only. The MCP wrapper in
  * bootstrap/db-tools.ts handles state-cache invalidation and STATE.md rebuild.
  */
-import { getSlice, getSliceTasks, isDbAvailable, transaction, updateSliceStatus, updateTaskStatus, } from "../gsd-db.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isDbAvailable, skipSliceCascade, } from "../gsd-db.js";
 /**
  * Mark a slice as "skipped" and cascade the skip to every non-closed task in
  * that slice. Runs as a single transaction so slice status and task statuses
@@ -39,40 +38,23 @@ export function handleSkipSlice(params) {
     if (!isDbAvailable()) {
         throw new Error("handleSkipSlice: GSD database is not available");
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ────
-    let guardError = null;
-    let guardCode = null;
-    let wasAlreadySkipped = false;
-    let tasksSkipped = 0;
-    transaction(() => {
-        const slice = getSlice(params.milestoneId, params.sliceId);
-        if (!slice) {
-            guardError = `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`;
-            guardCode = "slice_not_found";
-            return;
+    // ── Atomic skip cascade (guards + writes in one transaction) ────────────
+    const outcome = skipSliceCascade(params.milestoneId, params.sliceId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "slice-not-found":
+                return {
+                    ...base,
+                    error: `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`,
+                    errorCode: "slice_not_found",
+                };
+            case "slice-already-complete":
+                return {
+                    ...base,
+                    error: `Slice ${params.sliceId} is already complete — cannot skip.`,
+                    errorCode: "already_complete",
+                };
         }
-        if (slice.status === "complete" || slice.status === "done") {
-            guardError = `Slice ${params.sliceId} is already complete — cannot skip.`;
-            guardCode = "already_complete";
-            return;
-        }
-        wasAlreadySkipped = slice.status === "skipped";
-        if (!wasAlreadySkipped) {
-            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
-        }
-        // Cascade: mark every non-closed task as skipped so milestone completion
-        // doesn't trip the deep-task guard (#4375). Closed tasks (complete/done/
-        // skipped) are left untouched — we never downgrade.
-        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-        for (const task of tasks) {
-            if (!isClosedStatus(task.status)) {
-                updateTaskStatus(params.milestoneId, params.sliceId, task.id, "skipped");
-                tasksSkipped++;
-            }
-        }
-    });
-    if (guardError) {
-        return { ...base, error: guardError, errorCode: guardCode ?? undefined };
     }
-    return { ...base, tasksSkipped, wasAlreadySkipped };
+    return { ...base, tasksSkipped: outcome.tasksSkipped, wasAlreadySkipped: outcome.wasAlreadySkipped };
 }

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -6,9 +6,10 @@ import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, should
 import { getActiveRequirements, getAllMilestones, getMilestone, getSliceStatusSummary, getSliceTaskCounts, insertMilestone, insertAssessment, insertGateRun, readTransaction, saveGateResult, upsertQualityGate, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
-import { clearPathCache, relSliceFile, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { clearPathCache, normalizeRealPath, relSliceFile, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { unlinkSync } from "node:fs";
+import { hostname } from "node:os";
 import { join } from "node:path";
 import { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
@@ -25,9 +26,11 @@ import { logError, logWarning } from "../workflow-logger.js";
 import { invalidateStateCache } from "../state.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { parseProject } from "../schemas/parsers.js";
-import { getAutoRuntimeSnapshot } from "../auto-runtime-state.js";
+import { autoSession, getAutoRuntimeSnapshot, isAutoActive } from "../auto-runtime-state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { prepareUatRun, saveUatAttemptArtifact, } from "../uat-run.js";
+import { registerAutoWorker, markWorkerStopping, getAutoWorker } from "../db/auto-workers.js";
+import { claimMilestoneLease, releaseMilestoneLease, getMilestoneLease, refreshMilestoneLease, milestoneLeaseTtlSeconds, } from "../db/milestone-leases.js";
 export const SUPPORTED_SUMMARY_ARTIFACT_TYPES = [
     "SUMMARY",
     "RESEARCH",
@@ -61,6 +64,19 @@ function blockIfWrongAutoUnit(requiredUnitType, operation) {
         isError: true,
     };
 }
+function milestoneLeaseConflictResult(milestoneId, byWorker, expiresAt) {
+    return {
+        content: [{ type: "text", text: `Milestone ${milestoneId} is currently leased by ${byWorker}. Retry after ${expiresAt}.` }],
+        details: {
+            operation: "plan_milestone",
+            error: "milestone_lease_conflict",
+            milestoneId,
+            byWorker,
+            expiresAt,
+        },
+        isError: true,
+    };
+}
 function registerProjectMilestoneSequence(content) {
     const parsed = parseProject(content);
     const registered = [];
@@ -1066,7 +1082,45 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
             isError: true,
         };
     }
+    let workerId = null;
+    let acquiredToken = null;
+    let leaseRefreshTimer;
     try {
+        // Re-read at the gate so a peer-created milestone is not treated as fresh.
+        const milestoneExists = getMilestone(params.milestoneId) !== null;
+        if (milestoneExists) {
+            const heldLease = getMilestoneLease(params.milestoneId);
+            if (heldLease?.status === "held" && Date.parse(heldLease.expires_at) > Date.now()) {
+                const holder = getAutoWorker(heldLease.worker_id);
+                // Let the one-shot claim path recover stale same-process worker rows.
+                const projectRoot = normalizeRealPath(basePath);
+                const isOurAutoLease = isAutoActive() && heldLease.worker_id === autoSession.workerId;
+                const holderIsOneShotReentrantPeer = !isAutoActive()
+                    && !!holder
+                    && holder.host === hostname()
+                    && holder.pid === process.pid
+                    && holder.project_root_realpath === projectRoot;
+                if (holder?.status === "active" && !isOurAutoLease && !holderIsOneShotReentrantPeer) {
+                    return milestoneLeaseConflictResult(params.milestoneId, heldLease.worker_id, heldLease.expires_at);
+                }
+            }
+        }
+        // Fresh creation cannot claim a lease because the FK row does not exist.
+        // In-process auto already owns its lease; re-claiming would bump its token.
+        if (!isAutoActive() && milestoneExists) {
+            workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(basePath) });
+            const lease = claimMilestoneLease(workerId, params.milestoneId);
+            if (!lease.ok) {
+                return milestoneLeaseConflictResult(params.milestoneId, lease.byWorker, lease.expiresAt);
+            }
+            acquiredToken = lease.token;
+            const leaseRefreshMs = (milestoneLeaseTtlSeconds() / 2) * 1000;
+            leaseRefreshTimer = setInterval(() => {
+                if (acquiredToken !== null && workerId !== null) {
+                    refreshMilestoneLease(workerId, params.milestoneId, acquiredToken);
+                }
+            }, leaseRefreshMs);
+        }
         const result = await handlePlanMilestone(params, basePath);
         if ("error" in result) {
             return {
@@ -1093,6 +1147,17 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
             isError: true,
         };
     }
+    finally {
+        if (leaseRefreshTimer !== undefined) {
+            clearInterval(leaseRefreshTimer);
+        }
+        if (workerId !== null && acquiredToken !== null) {
+            releaseMilestoneLease(workerId, params.milestoneId, acquiredToken);
+        }
+        if (workerId !== null) {
+            markWorkerStopping(workerId);
+        }
+    }
 }
 export async function executePlanSlice(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);

package/dist/resources/extensions/gsd/uat-policy.js

@@ -1,16 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Central UAT mode policy for dispatch, tool presentation, and result validation.
-import { extractUatType } from "./files.js";
+import { hasBrowserContractPrefix } from "../shared/browser-contract.js";
+import { extractUatType, UAT_TYPE_KEYWORDS } from "./files.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
 import { parseMcpToolName } from "./mcp-tool-name.js";
-export const UAT_TYPES = [
-    "artifact-driven",
-    "browser-executable",
-    "runtime-executable",
-    "live-runtime",
-    "mixed",
-    "human-experience",
-];
+export const UAT_TYPES = UAT_TYPE_KEYWORDS;
 export const UAT_MODE_POLICIES = {
     "artifact-driven": {
         browserTools: false,
@@ -55,23 +49,55 @@ export function isUatType(value) {
 export function getDeclaredUatType(content) {
     return extractUatType(content) ?? "artifact-driven";
 }
-export function classifyUatContent(content) {
-    const declaredType = getDeclaredUatType(content);
-    const browserRequired = hasBrowserRequiredText(content);
-    const effectiveType = declaredType === "artifact-driven" && browserRequired
+/** Self-contained browser UAT harnesses that manage server lifecycle internally. */
+const SELF_CONTAINED_RUNTIME_UAT_COMMAND_RE = /\b(?:npm run test:uat|node\s+(?:--check\s+\S+\s+&&\s+)*tests\/browser\/search-uat\.mjs|npx playwright test(?:\s+\S+)?)\b/i;
+export function hasSelfContainedRuntimeUatCommand(content) {
+    return SELF_CONTAINED_RUNTIME_UAT_COMMAND_RE.test(content);
+}
+function resolveEffectiveUatTypeFromPolicy(declaredType, browserRequired, content) {
+    let effectiveType = declaredType === "artifact-driven" && browserRequired
         ? "browser-executable"
         : declaredType;
+    // M006/S01 regression: specs often declare browser-executable with localhost
+    // preconditions while the Evidence section names a runtime harness such as
+    // `npm run test:uat`. Interactive browser_* checks then race a fixed port
+    // against the script's own ephemeral server — run the harness instead.
+    if (effectiveType === "browser-executable" &&
+        hasSelfContainedRuntimeUatCommand(content)) {
+        effectiveType = "runtime-executable";
+    }
+    return effectiveType;
+}
+export function classifyUatContent(content) {
+    return classifyUatContentForRun(content);
+}
+/**
+ * Classify UAT mode for run-uat dispatch. Supplemental context (slice summary,
+ * verification excerpts) can name a self-contained harness even when the UAT
+ * file only documents a separate server command such as `npm run test:server`.
+ */
+export function classifyUatContentForRun(content, supplementalContext = "") {
+    const parsedType = extractUatType(content);
+    const declaredType = parsedType ?? "artifact-driven";
+    const browserRequired = hasBrowserRequiredText(content);
+    const combinedForHarness = supplementalContext.trim()
+        ? `${content}\n\n${supplementalContext}`
+        : content;
+    const effectiveType = resolveEffectiveUatTypeFromPolicy(declaredType, browserRequired, combinedForHarness);
     return {
         declaredType,
+        modeDeclared: parsedType !== undefined,
         effectiveType,
         browserRequired,
         shouldDispatchByDefault: effectiveType !== "artifact-driven" || browserRequired,
     };
 }
-export function shouldEscalateArtifactUatToBrowser(content) {
-    const policy = classifyUatContent(content);
+export function escalatesArtifactUatToBrowser(policy) {
     return policy.declaredType === "artifact-driven" && policy.browserRequired;
 }
+export function shouldEscalateArtifactUatToBrowser(content) {
+    return escalatesArtifactUatToBrowser(classifyUatContent(content));
+}
 export function resolveEffectiveUatType(content) {
     return classifyUatContent(content).effectiveType;
 }
@@ -84,7 +110,7 @@ export function uatTypeIncludesBrowser(uatType) {
 export function isUatBrowserToolName(toolName) {
     const parsed = parseMcpToolName(toolName);
     const canonicalName = parsed?.toolName ?? toolName;
-    if (canonicalName.startsWith("browser_"))
+    if (hasBrowserContractPrefix(canonicalName))
         return true;
     return parsed?.toolName === "*" && parsed.serverName.toLowerCase().includes("browser");
 }

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

@@ -11,7 +11,7 @@ import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
-import { getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { getTask, getSlice, getSliceTasks, updateTaskStatus, resetSliceCascade } from "./gsd-db.js";
 import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
 /**
  * Undo the last completed unit: revert git commits,
@@ -275,20 +275,21 @@ export async function handleResetSlice(args, ctx, _pi, basePath) {
             `Run /gsd reset-slice ${rawId} --force to confirm.`, "warning");
         return;
     }
-    // Reset all tasks
-    let tasksReset = 0;
+    // Reset all task statuses to "pending" and the slice to "active" in one
+    // atomic commit (DB is source of truth). Previously a per-task updateTaskStatus
+    // loop + a separate updateSliceStatus, which could leave a partial reset if
+    // interrupted mid-loop.
+    resetSliceCascade(mid, sid);
+    // Delete task summary files — projection cleanup, separate from the DB reset.
+    const tasksReset = tasks.length;
     let summariesDeleted = 0;
     for (const t of tasks) {
-        updateTaskStatus(mid, sid, t.id, "pending");
-        tasksReset++;
         const summaryPath = resolveTaskFile(basePath, mid, sid, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             unlinkSync(summaryPath);
             summariesDeleted++;
         }
     }
-    // Reset slice status
-    updateSliceStatus(mid, sid, "active");
     // Delete slice summary and UAT files
     let sliceFilesDeleted = 0;
     const slicePath = resolveSlicePath(basePath, mid, sid);