@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.955e4da0

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/validate-milestone.js

@@ -11,10 +11,11 @@
  * despite passing validation.
  */
 import { join } from "node:path";
-import { transaction, insertAssessment, getMilestoneSlices, getMilestone, getArtifact, } from "../gsd-db.js";
-import { gsdProjectionRoot, clearPathCache, resolveSliceFile } from "../paths.js";
+import { transaction, insertAssessment, getMilestoneSlices, getMilestone, } from "../gsd-db.js";
+import { gsdProjectionRoot, clearPathCache } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
-import { saveFile, clearParseCache, loadFile } from "../files.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
+import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
@@ -22,7 +23,7 @@ import { logWarning } from "../workflow-logger.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { resolveUokFlags } from "../uok/flags.js";
-import { compactTextParts, hasBrowserEvidenceText, hasBrowserRequiredText } from "../browser-evidence.js";
+import { applyBrowserEvidenceGate, browserEvidenceGateRequiresAttention, } from "../milestone-validation-evidence.js";
 function isVerificationNotApplicable(value) {
     const v = (value ?? "").toLowerCase().trim().replace(/[.\s]+$/, "");
     if (!v || v === "none")
@@ -44,80 +45,6 @@ function getRequiredVerificationClasses(milestoneId) {
         required.push("UAT");
     return required;
 }
-function hasRuntimeExecutableUatEvidenceText(text) {
-    if (!/\buatType:\s*runtime-executable\b/i.test(text))
-        return false;
-    if (!/\bverdict:\s*PASS\b/i.test(text))
-        return false;
-    return /^\|\s*[^|\n]+\s*\|\s*runtime\s*\|\s*PASS\s*\|[^|\n]*\bgsd_uat_exec\b/mi.test(text);
-}
-async function browserEvidenceGateRequiresAttention(params, basePath) {
-    if (params.verdict !== "pass")
-        return false;
-    const milestone = getMilestone(params.milestoneId);
-    const slices = getMilestoneSlices(params.milestoneId);
-    const requirementText = compactTextParts([
-        milestone?.vision,
-        milestone?.success_criteria,
-        milestone?.verification_uat,
-        params.successCriteriaChecklist,
-        params.verificationClasses,
-        ...slices.flatMap((slice) => [
-            slice.demo,
-            slice.goal,
-            slice.success_criteria,
-        ]),
-    ]);
-    if (!hasBrowserRequiredText(requirementText))
-        return false;
-    // Collect per-slice evidence so the runtime bypass is checked independently
-    // for each slice. Concatenating all slices before checking would allow runtime
-    // evidence from one slice to cover another slice's browser requirements.
-    const sliceEvidencePairs = [];
-    for (const slice of slices) {
-        const chunks = [];
-        const artifactPath = `milestones/${params.milestoneId}/slices/${slice.id}/${slice.id}-ASSESSMENT.md`;
-        const artifact = getArtifact(artifactPath);
-        if (artifact?.full_content)
-            chunks.push(artifact.full_content);
-        const assessmentPath = resolveSliceFile(basePath, params.milestoneId, slice.id, "ASSESSMENT");
-        const assessmentContent = assessmentPath ? await loadFile(assessmentPath) : null;
-        if (assessmentContent)
-            chunks.push(assessmentContent);
-        sliceEvidencePairs.push({
-            sliceRequirementText: compactTextParts([slice.demo, slice.goal, slice.success_criteria]),
-            evidenceText: chunks.join("\n\n"),
-        });
-    }
-    const persistedEvidence = sliceEvidencePairs.map((s) => s.evidenceText).join("\n\n");
-    // Runtime bypass: each slice whose own requirement text has browser-observable
-    // criteria must have its own runtime-executable UAT evidence. When no individual
-    // slice has slice-level browser requirements (e.g., they come from milestone-level
-    // fields only), fall back to checking whether any slice has runtime evidence.
-    const browserRequiringSlices = sliceEvidencePairs.filter((s) => hasBrowserRequiredText(s.sliceRequirementText));
-    const runtimeBypasses = browserRequiringSlices.length > 0
-        ? browserRequiringSlices.every((s) => hasRuntimeExecutableUatEvidenceText(s.evidenceText))
-        : sliceEvidencePairs.some((s) => hasRuntimeExecutableUatEvidenceText(s.evidenceText));
-    if (runtimeBypasses)
-        return false;
-    const validationEvidence = compactTextParts([
-        params.successCriteriaChecklist,
-        params.verificationClasses,
-        params.verdictRationale,
-        params.remediationPlan,
-    ]);
-    return !hasBrowserEvidenceText(`${persistedEvidence}\n\n${validationEvidence}`);
-}
-function applyBrowserEvidenceGate(params) {
-    const note = "Browser evidence gate: Browser-observable acceptance criteria were detected, but no persisted ASSESSMENT or validation evidence recorded browser actions with assertions. Downgraded from pass to needs-attention.";
-    return {
-        ...params,
-        verdict: "needs-attention",
-        verdictRationale: params.verdictRationale.trim()
-            ? `${params.verdictRationale.trim()}\n\n${note}`
-            : note,
-    };
-}
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -214,6 +141,16 @@ export async function handleValidateMilestone(params, basePath, opts) {
     let projectionStale = false;
     try {
         await saveFile(validationPath, validationMd);
+        const projectRoot = resolveWorktreeProjectRoot(basePath);
+        if (projectRoot !== artifactBasePath) {
+            const projectValidationPath = join(gsdProjectionRoot(projectRoot), "milestones", effectiveParams.milestoneId, `${effectiveParams.milestoneId}-VALIDATION.md`);
+            try {
+                await saveFile(projectValidationPath, validationMd);
+            }
+            catch (mirrorErr) {
+                logWarning("projection", `validate_milestone project-root VALIDATION mirror failed for ${effectiveParams.milestoneId}`, { error: mirrorErr.message });
+            }
+        }
     }
     catch (renderErr) {
         projectionStale = true;

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

@@ -2,6 +2,7 @@
 // File Purpose: Central UAT mode policy for dispatch, tool presentation, and result validation.
 import { extractUatType } from "./files.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
+import { parseMcpToolName } from "./mcp-tool-name.js";
 export const UAT_TYPES = [
     "artifact-driven",
     "browser-executable",
@@ -80,26 +81,31 @@ export function shouldDispatchUatForContent(content, prefs) {
 export function uatTypeIncludesBrowser(uatType) {
     return isUatType(uatType) && UAT_MODE_POLICIES[uatType].browserTools;
 }
-function canonicalPresentedToolName(toolName) {
-    if (!toolName.startsWith("mcp__"))
-        return toolName;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    return toolSeparator >= 0 ? toolName.slice(toolSeparator + 2) : toolName;
-}
 export function isUatBrowserToolName(toolName) {
-    return canonicalPresentedToolName(toolName).startsWith("browser_");
+    const parsed = parseMcpToolName(toolName);
+    const canonicalName = parsed?.toolName ?? toolName;
+    if (canonicalName.startsWith("browser_"))
+        return true;
+    return parsed?.toolName === "*" && parsed.serverName.toLowerCase().includes("browser");
 }
 export function hasUatBrowserToolSurface(activeTools) {
     return Array.isArray(activeTools) && activeTools.some(isUatBrowserToolName);
 }
+export function resolveUatBrowserToolSurface(options) {
+    const surfaces = [options.activeTools, options.registeredTools].filter(Array.isArray);
+    if (surfaces.length === 0)
+        return undefined;
+    return [...new Set(surfaces.flat())];
+}
 export function getUatBrowserToolSupportError(options) {
     if (!uatTypeIncludesBrowser(options.uatType))
         return null;
-    if (!Array.isArray(options.activeTools))
+    const toolSurface = resolveUatBrowserToolSurface(options);
+    if (!toolSurface)
         return null;
-    if (hasUatBrowserToolSurface(options.activeTools))
+    if (hasUatBrowserToolSurface(toolSurface))
         return null;
-    return `Cannot dispatch browser-backed run-uat for ${options.milestoneId}/${options.sliceId}: UAT mode "${options.uatType}" requires browser tools, but the active tool surface has none. Enable browser tools or change the UAT to a runtime-executable Playwright command, then rerun /gsd auto.`;
+    return `Cannot dispatch browser-backed run-uat for ${options.milestoneId}/${options.sliceId}: UAT mode "${options.uatType}" requires browser tools, but the run-uat tool surface has none. Enable browser tools or change the UAT to a runtime-executable Playwright command, then rerun /gsd auto.`;
 }
 export function isPartialEligibleUatType(uatType) {
     return !!uatType && UAT_MODE_POLICIES[uatType].partialEligible;

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

@@ -13,7 +13,7 @@ function isNonEmptyString(value) {
 function mergeBlockedTools(current, canonical) {
     const merged = new Map();
     for (const entry of [...(current ?? []), ...canonical]) {
-        merged.set(canonicalWorkflowToolName(parseMcpToolName(entry.name)?.tool ?? entry.name), entry);
+        merged.set(canonicalWorkflowToolName(parseMcpToolName(entry.name)?.toolName ?? entry.name), entry);
     }
     return [...merged.values()];
 }
@@ -204,20 +204,15 @@ function quoteToolNames(toolNames) {
     return toolNames.map((toolName) => `"${toolName}"`).join(", ");
 }
 function validateCanonicalPresentation(params) {
-    const aliasHints = {
-        gsd_save_summary: "gsd_summary_save",
-        gsd_complete_task: "gsd_task_complete",
-        gsd_complete_slice: "gsd_slice_complete",
-        gsd_milestone_complete: "gsd_complete_milestone",
-    };
     const errors = [];
     for (const toolName of params.presentation.presentedTools) {
-        const baseName = parseMcpToolName(toolName)?.tool ?? toolName;
-        const canonical = aliasHints[baseName];
-        if (canonical)
+        const baseName = parseMcpToolName(toolName)?.toolName ?? toolName;
+        const canonical = canonicalWorkflowToolName(baseName);
+        if (canonical !== baseName) {
             errors.push(`presentation tool "${toolName}" uses an alias; use canonical "${canonical}"`);
+        }
     }
-    const presentedCanonical = new Set(params.presentation.presentedTools.map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName)));
+    const presentedCanonical = new Set(params.presentation.presentedTools.map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName)));
     const missingRequiredTools = RUN_UAT_WORKFLOW_TOOL_NAMES.filter((requiredTool) => !presentedCanonical.has(requiredTool));
     if (missingRequiredTools.length === 1) {
         errors.push(`presentation is missing required UAT tool "${missingRequiredTools[0]}"`);
@@ -227,10 +222,10 @@ function validateCanonicalPresentation(params) {
     }
     const forbiddenCanonical = new Set(RUN_UAT_FORBIDDEN_TOOL_NAMES
         .filter((toolName) => !toolName.includes("*"))
-        .map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName)));
+        .map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName)));
     const forbiddenPresentedTools = [];
     for (const toolName of params.presentation.presentedTools) {
-        const canonical = canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName);
+        const canonical = canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName);
         if (toolName === "mcp__gsd-workflow__*" || forbiddenCanonical.has(canonical)) {
             forbiddenPresentedTools.push(toolName);
         }
@@ -241,7 +236,7 @@ function validateCanonicalPresentation(params) {
     else if (forbiddenPresentedTools.length > 1) {
         errors.push(`presentation includes forbidden run-uat tools ${quoteToolNames(forbiddenPresentedTools)}`);
     }
-    const blockedCanonical = new Set(params.presentation.blockedTools.map((entry) => canonicalWorkflowToolName(parseMcpToolName(entry.name)?.tool ?? entry.name)));
+    const blockedCanonical = new Set(params.presentation.blockedTools.map((entry) => canonicalWorkflowToolName(parseMcpToolName(entry.name)?.toolName ?? entry.name)));
     const missingBlockedTools = ["gsd_exec", "gsd_summary_save", "gsd_save_gate_result"].filter((blockedTool) => !blockedCanonical.has(blockedTool));
     if (missingBlockedTools.length === 1) {
         errors.push(`presentation must record "${missingBlockedTools[0]}" as blocked during run-uat`);

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);

package/dist/resources/extensions/gsd/unit-context-composer.js

@@ -135,37 +135,56 @@ export async function composeUnitContext(unitType, opts) {
     const manifest = resolveManifest(unitType);
     if (!manifest)
         return { prepend: "", inline: "" };
-    // Single-source `unitType`: the manifest is resolved against the
+    const composed = await composeDeclaredUnitContext({
+        unitType,
+        artifacts: {
+            inline: manifest.artifacts.inline,
+            excerpt: manifest.artifacts.excerpt,
+            onDemand: manifest.artifacts.onDemand,
+            computed: manifest.artifacts.computed ?? [],
+            prepend: manifest.prepend ?? [],
+        },
+    }, opts);
+    return {
+        prepend: composed.prepend,
+        inline: composed.inline,
+    };
+}
+export async function composeContractedUnitContext(contract, opts) {
+    return composeDeclaredUnitContext(contract, opts);
+}
+async function composeDeclaredUnitContext(contract, opts) {
+    // Single-source `unitType`: contract/manifest selection comes from the
     // function arg, but computed builders read it from `base.unitType`.
-    // If those ever diverge (caller passes one type to composeUnitContext
-    // but a different one in opts.base), the composer would silently
-    // mix one unit's manifest with another unit's computed context.
-    // Normalize here so the composer dispatches a consistent identity
-    // through to every builder.
+    // Normalize here so every builder sees the same Unit identity.
     const normalizedOpts = {
         ...opts,
-        base: { ...opts.base, unitType },
+        base: { ...opts.base, unitType: contract.unitType },
     };
-    const prependBlocks = await runComputed(manifest.prepend ?? [], normalizedOpts);
+    const prependBlocks = await runComputedBlocks(contract.artifacts.prepend, normalizedOpts, "prepend");
     const inlineBlocks = [];
-    for (const key of manifest.artifacts.inline) {
+    for (const key of contract.artifacts.inline) {
         if (!normalizedOpts.resolveArtifact)
             break;
         const body = await normalizedOpts.resolveArtifact(key);
-        if (body && body.length > 0)
-            inlineBlocks.push(body);
+        if (body && body.length > 0) {
+            inlineBlocks.push({ key, mode: "inline", body });
+        }
     }
-    for (const key of manifest.artifacts.excerpt) {
+    for (const key of contract.artifacts.excerpt) {
         if (!normalizedOpts.resolveExcerpt)
             break;
         const body = await normalizedOpts.resolveExcerpt(key);
-        if (body && body.length > 0)
-            inlineBlocks.push(body);
+        if (body && body.length > 0) {
+            inlineBlocks.push({ key, mode: "excerpt", body });
+        }
     }
-    inlineBlocks.push(...await runComputed(manifest.artifacts.computed ?? [], normalizedOpts));
+    inlineBlocks.push(...await runComputedBlocks(contract.artifacts.computed, normalizedOpts, "computed"));
     return {
-        prepend: prependBlocks.join(SECTION_SEPARATOR),
-        inline: inlineBlocks.join(SECTION_SEPARATOR),
+        prepend: prependBlocks.map((block) => block.body).join(SECTION_SEPARATOR),
+        inline: inlineBlocks.map((block) => block.body).join(SECTION_SEPARATOR),
+        blocks: [...prependBlocks, ...inlineBlocks],
+        onDemand: contract.artifacts.onDemand,
     };
 }
 /**
@@ -173,7 +192,7 @@ export async function composeUnitContext(unitType, opts) {
  * Missing registry entries (manifest declares the id but caller didn't
  * register it) are skipped silently — see composeUnitContext rationale.
  */
-async function runComputed(ids, opts) {
+async function runComputedBlocks(ids, opts, mode) {
     if (ids.length === 0 || !opts.computed)
         return [];
     const registry = opts.computed;
@@ -183,8 +202,9 @@ async function runComputed(ids, opts) {
         if (!entry)
             continue;
         const body = await entry.build(entry.inputs, opts.base);
-        if (body && body.length > 0)
-            out.push(body);
+        if (body && body.length > 0) {
+            out.push({ key: id, mode, body });
+        }
     }
     return out;
 }

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -4,7 +4,8 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { gsdRoot, relSliceFile, relTaskFile, resolveSliceFile, resolveTaskFile, } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { parseUnitId } from "./unit-id.js";
-import { getTask, isDbAvailable, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { getTask, isDbAvailable } from "./gsd-db.js";
+import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
 // Per-record advisory lock — prevents read-modify-write races between
 // concurrent writers updating disjoint fields of the same runtime record.
@@ -169,7 +170,7 @@ export async function inspectExecuteTaskDurability(basePath, unitId) {
     const nextActionAdvanced = !new RegExp(`Execute ${tid}\\b`).test(stateContent);
     let dbComplete = false;
     if (isDbAvailable()) {
-        refreshOpenDatabaseFromDisk();
+        refreshWorkflowDatabaseFromDisk();
         const task = getTask(mid, sid, tid);
         dbComplete = !!task && isClosedStatus(task.status);
     }

package/dist/resources/extensions/gsd/unit-tool-contracts.js

@@ -60,6 +60,7 @@ export const UNIT_TOOL_CONTRACTS = {
             "gsd_milestone_generate_id",
         ],
         requiredWorkflowTools: [
+            "ask_user_questions",
             "gsd_summary_save",
             "gsd_requirement_save",
             "gsd_requirement_update",
@@ -69,7 +70,7 @@ export const UNIT_TOOL_CONTRACTS = {
     },
     "discuss-slice": {
         allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
-        requiredWorkflowTools: ["gsd_summary_save"],
+        requiredWorkflowTools: ["ask_user_questions", "gsd_summary_save"],
     },
     "validate-milestone": {
         allowedGsdTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],

package/dist/resources/extensions/gsd/user-input-boundary.js

@@ -177,6 +177,29 @@ export function isAwaitingApprovalBoundary(messages) {
         return true;
     return hasApprovalQuestion(text);
 }
+/** True when an assistant message already has an in-flight ask_user_questions tool call. */
+export function messageHasPendingAskUserQuestionsTool(message) {
+    if (!message || typeof message !== "object")
+        return false;
+    const content = message.content;
+    if (!Array.isArray(content))
+        return false;
+    return content.some((block) => {
+        if (!block || typeof block !== "object")
+            return false;
+        // Claude Code marks completion by attaching externalResult, not by setting state.
+        // Streaming blocks often carry no state; serverToolUse is the claude-code-cli MCP path.
+        const tool = block;
+        if (tool.type !== "toolCall" && tool.type !== "serverToolUse")
+            return false;
+        const name = String(tool.name ?? "").toLowerCase();
+        if (!name.includes("ask_user_questions"))
+            return false;
+        if (tool.externalResult !== undefined)
+            return false;
+        return tool.state !== "completed" && tool.state !== "done";
+    });
+}
 export function shouldPauseForUserApprovalQuestion(unitType, messages) {
     if (!unitType || !USER_APPROVAL_UNIT_TYPES.has(unitType))
         return false;

package/dist/resources/extensions/gsd/validation-block-guard.js

@@ -3,6 +3,7 @@
 import { existsSync } from "node:fs";
 import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
+import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getIsolationMode } from "./preferences.js";
 import { deriveState } from "./state.js";
 import { detectWorktreeName } from "./worktree.js";
@@ -72,6 +73,7 @@ export function formatValidationBlockedMessage(state, attemptedCommand = "") {
 }
 export async function getValidationBlockMessageForBase(base, attemptedCommand = "") {
     await ensureDbOpen(base);
+    refreshWorkflowDatabaseFromDisk();
     let state = await deriveState(base);
     if (state.activeMilestone &&
         getIsolationMode(base) === "worktree" &&

package/dist/resources/extensions/gsd/web-app-uat.js

@@ -0,0 +1,80 @@
+// Project/App: gsd-pi
+// File Purpose: Web-app detection and Playwright/UAT guidance for planning and slice closeout.
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { detectWebApp } from "../browser-tools/web-app-detect.js";
+export { detectWebApp };
+function readPackageJson(projectRoot) {
+    const packageJsonPath = resolve(projectRoot, "package.json");
+    if (!existsSync(packageJsonPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function hasPlaywrightTestDependency(projectRoot) {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg)
+        return false;
+    const names = [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+    ];
+    return names.some((name) => name === "playwright" || name === "@playwright/test");
+}
+export function findPlaywrightTestScript(projectRoot) {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg?.scripts)
+        return null;
+    for (const [name, value] of Object.entries(pkg.scripts)) {
+        if (typeof value !== "string")
+            continue;
+        if (/\bplaywright\s+test\b/.test(value)) {
+            return `npm run ${name}`;
+        }
+    }
+    return null;
+}
+/**
+ * Markdown block injected into plan/complete-slice prompts when the project
+ * looks browser-facing. Returns null for CLI/library-only repos.
+ */
+export function buildWebAppUatGuidanceBlock(projectRoot) {
+    if (!detectWebApp(projectRoot))
+        return null;
+    const playwrightScript = findPlaywrightTestScript(projectRoot);
+    const hasPlaywright = hasPlaywrightTestDependency(projectRoot) || playwrightScript !== null;
+    const lines = [
+        "### Web App UAT (detected)",
+        "",
+        "This project looks browser-facing. GSD exposes Playwright-backed `browser_*` tools by default for run-uat.",
+        "",
+        "**UAT modes (pick one per slice — do not use `artifact-driven` for browser steps):**",
+        "- `browser-executable` — navigate to `http://localhost:…`, click, screenshot, assert via `browser_*` tools during run-uat",
+        "- `runtime-executable` — run an automated browser test command via `gsd_uat_exec` (for example `npx playwright test`)",
+        "- `mixed` / `live-runtime` — combine runtime startup checks with interactive browser verification",
+        "",
+        "**Planning / closeout rules:**",
+        "- Preconditions must name the dev-server command and URL (for example `npm run dev` → `http://localhost:3000`)",
+        "- Slice Verification and UAT test cases must not say \"open in browser\" under `artifact-driven` — complete-slice rejects that",
+        "- Milestone `Verification Classes` → UAT row must describe browser-observable acceptance, not \"manual spot check\" alone",
+    ];
+    if (hasPlaywright) {
+        lines.push("", "**Playwright:** dependency detected.");
+        if (playwrightScript) {
+            lines.push(`- Prefer slice verification and runtime-executable UAT referencing \`${playwrightScript}\` or a focused \`npx playwright test <spec>\` command`);
+        }
+        else {
+            lines.push("- Prefer runtime-executable UAT with `npx playwright test` (or a focused spec path) when UI behavior is covered by specs");
+        }
+        lines.push("- Name concrete spec paths in slice Verification (for example `e2e/smoke.spec.ts`)");
+    }
+    else {
+        lines.push("", "**Playwright scaffolding (first UI slice):** no `playwright` / `@playwright/test` dependency yet.", "- Add a planning task that installs Playwright, adds `playwright.config.ts`, and creates a minimal smoke spec (for example `e2e/smoke.spec.ts`)", "- Task `verify` should run `npx playwright test` (or the focused spec) with a safe, simple command", "- Until specs exist, use `browser-executable` UAT with localhost preconditions and interactive `browser_*` checks at slice closeout");
+    }
+    return lines.join("\n");
+}