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

package/dist/resources/extensions/gsd/prompts/guided-discuss-project.md

@@ -36,6 +36,8 @@ After the opening answer, classify project shape as **`simple`** or **`complex`*
 
 Persist the verdict through `gsd_summary_save` with `artifact_type: "PROJECT"` into `## Project Shape`; downstream `discuss-requirements`, `discuss-milestone`, and `discuss-slice` read the rendered projection.
 
+When the project is browser-facing (web app, SPA, static site with UI, Next/React/Vue, etc.), also record **`Web stack:`** under `## Project Shape` (framework + whether Playwright or browser UAT is expected). Downstream planning uses this to choose `browser-executable` / `runtime-executable` UAT instead of deferring UI proof to humans.
+
 ### Before deeper rounds
 
 Ground your questions in the **Preparation Context snapshot above** (stack, structure, greenfield/brownfield and framework signals) plus any prior `.planning/` or `.gsd/` artifacts — those are authoritative. **Do not survey the codebase** with `rg`/`find`/`scout` before asking; read a specific file only when a question's answer genuinely hinges on it.
@@ -103,7 +105,7 @@ Once the user confirms depth:
 
 1. Use the **Project** output template (inlined above).
 2. Call `gsd_summary_save` with `artifact_type: "PROJECT"` and full project markdown as `content`; omit `milestone_id`. The tool persists the DB-backed PROJECT artifact and renders `.gsd/PROJECT.md`. Preserve the user's terms and framing.
-3. The `## Project Shape` section MUST contain `**Complexity:** simple` or `**Complexity:** complex` (matching the verdict you announced) plus a one-line `**Why:**` rationale. Downstream stages read this line.
+3. The `## Project Shape` section MUST contain `**Complexity:** simple` or `**Complexity:** complex` (matching the verdict you announced) plus a one-line `**Why:**` rationale. For browser-facing projects, also include `**Web stack:**` (framework and expected browser/Playwright UAT approach). Downstream stages read these lines.
 4. The `## Capability Contract` section MUST reference `.gsd/REQUIREMENTS.md` — that file does not yet exist; the next stage (`discuss-requirements`) will produce it.
 5. The `## Milestone Sequence` MUST list at least M001 with title and one-liner. Subsequent milestones may be listed as known intents; they will be elaborated in their own discuss-milestone stages.
 6. Do NOT use `artifact_type: "CONTEXT"` and do NOT pass `milestone_id: "PROJECT"`; that creates a fake milestone named PROJECT.

package/dist/resources/extensions/gsd/prompts/plan-milestone.md

@@ -47,6 +47,8 @@ If milestone research is inlined, trust it and skip redundant exploration. If fi
 
 Narrate decomposition reasoning in complete sentences: grouping, risk order, verification strategy.
 
+**Web apps:** when inlined Web App UAT guidance is present, set milestone `Verification Classes` → UAT to browser-observable acceptance (Playwright spec or `browser_*` checks). Order an early slice to add Playwright smoke scaffolding when the dependency is missing.
+
 Then:
 1. Use the **Roadmap** output template from the inlined context above
 2. {{skillActivation}}

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -41,6 +41,7 @@ If slice research is inlined, trust its architectural findings, but verify every
 3. Use the inlined Output Template sections already present in this prompt. Do not read template files from disk.
 4. {{skillActivation}} Record expected executor skills in each task plan's `skills_used` frontmatter.
 5. Define slice verification before tasks. Non-trivial slices need real tests or executable assertions; boundary contracts need contract-exercising checks. Tests must not read .gitignore/gitignored paths such as `.gsd/`, `.planning/`, or `.audits/`.
+   **Web apps:** when inlined Web App UAT guidance is present, follow it — add Playwright smoke scaffolding on the first UI slice if missing, name localhost preconditions, and plan verification commands that match browser-capable UAT modes at slice closeout.
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
 8. Task `verify` commands must be safe, simple commands. Do not use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`. If multiple checks are needed, create a small test file and run it with `node --test` or a package test script, or use separate simple commands joined only with `&&`. For absence checks, verify a pattern does not exist with `! grep -q 'pattern' file` or `! rg -q 'pattern' file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches, and the verification gate treats that as failure.

package/dist/resources/extensions/gsd/prompts/refine-slice.md

@@ -63,6 +63,7 @@ Then:
    - `{{taskPlanTemplatePath}}`
 2. {{skillActivation}} Record the installed skills you expect executors to use in each task plan's `skills_used` frontmatter.
 3. Define slice-level verification: the objective stopping condition. Plan real test files with real assertions; for simple slices, executable commands are fine.
+   **Web apps:** when inlined Web App UAT guidance is present, follow it for Playwright scaffolding and browser-capable verification commands.
 4. For non-trivial slices, plan observability / proof level / integration closure, threat surface, and requirement impact. Omit entirely for simple slices.
 5. Decompose the slice into tasks that fit one context window each. Every task passed to `gsd_plan_slice` must use the exact keys `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. Put Why / Do / Done-when detail in `description`. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even for one path (for example, `"expectedOutput": ["src/index.ts"]`, never `"expectedOutput": "src/index.ts"`). `expectedOutput` is path-only: list only files the task creates or overwrites, and use `[]` for pure verification tasks.
 6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` automatically. Do NOT rely on direct `PLAN.md` writes.

package/dist/resources/extensions/gsd/prompts/system.md

@@ -158,7 +158,7 @@ Fix root causes, not symptoms. If applying temporary mitigation, label it and pr
 - State uncertainty plainly: "Not sure this handles X - testing it." No performed confidence, no hedging paragraphs.
 - All user-visible narration must be grammatical English. Do not emit compressed planner notes like "Need inspect X". If it fits a commit comment or standup note, it is acceptable.
 - When debugging, stay curious. Problems are puzzles. Say what's interesting about the failure before reaching for fixes.
-- After completing a task, give a brief summary and 2-4 numbered next-step options; last option is always "Other". Omit the list for strict output formats.
+- After completing a task, give a brief summary and 2-4 numbered next-step options; last option is always "Other". Omit the list for strict output formats, or when the active workflow prompt already ends with its own explicit "Next steps:" handoff block — in that case follow the workflow's handoff and do not add a second list.
 
   If any next step is destructive/outward-facing, present it via `ask_user_questions` and wait for the user's answer before execution. Do not execute a next-step item from a prior plain-text numbered list without fresh confirmation.
 

package/dist/resources/extensions/gsd/provider-payload-policy.js

@@ -0,0 +1,83 @@
+/**
+ * Provider Payload Policy - ordered shaping of provider request payloads.
+ *
+ * The order is intentional:
+ * 1. observation budgeting masks old tool results in auto-mode,
+ * 2. display truncation caps tool-result text for every mode,
+ * 3. the protected Source Context Block is appended after truncation,
+ * 4. supported models receive the configured service tier.
+ */
+import { createObservationMask, createResponsesInputObservationMask, truncateContextResultMessages, truncateResponsesInputResultItems, } from "./context-masker.js";
+import { getSourceObservationStore, isAutoActive } from "./auto-runtime-state.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { getEffectiveServiceTier, supportsServiceTier } from "./service-tier.js";
+import { injectSourceContextBlockIntoPayload } from "./source-observations.js";
+const DEFAULT_OBSERVATION_MASK_TURNS = 8;
+const DEFAULT_TOOL_RESULT_MAX_CHARS = 800;
+export const DEFAULT_PROVIDER_PAYLOAD_POLICY_DEPS = {
+    isAutoActive,
+    loadContextManagementConfig: () => loadEffectiveGSDPreferences()?.preferences.context_management,
+    renderSourceContextBlock: () => getSourceObservationStore().renderActiveBlock(),
+    getEffectiveServiceTier,
+    supportsServiceTier,
+};
+export function applyProviderPayloadPolicy({ payload, modelId, deps: overrides, }) {
+    const deps = { ...DEFAULT_PROVIDER_PAYLOAD_POLICY_DEPS, ...overrides };
+    try {
+        applyContextManagement(payload, deps);
+    }
+    catch {
+        // Provider payload shaping should not block a request when optional
+        // context management preferences or adapters fail.
+    }
+    try {
+        applySourceContextBlock(payload, deps);
+    }
+    catch {
+        // Source observations are opportunistic; execution can continue without
+        // an injected block.
+    }
+    applyServiceTier(payload, modelId, deps);
+    return payload;
+}
+function applyContextManagement(payload, deps) {
+    const config = deps.loadContextManagementConfig();
+    applyObservationBudget(payload, config, deps.isAutoActive());
+    applyDisplayTruncation(payload, config);
+}
+function applyObservationBudget(payload, config, autoActive) {
+    if (!autoActive || config?.observation_masking === false)
+        return;
+    const keepTurns = config?.observation_mask_turns ?? DEFAULT_OBSERVATION_MASK_TURNS;
+    if (Array.isArray(payload.messages)) {
+        payload.messages = createObservationMask(keepTurns)(payload.messages);
+    }
+    if (Array.isArray(payload.input)) {
+        payload.input = createResponsesInputObservationMask(keepTurns)(payload.input);
+    }
+}
+function applyDisplayTruncation(payload, config) {
+    const maxChars = config?.tool_result_max_chars ?? DEFAULT_TOOL_RESULT_MAX_CHARS;
+    if (Array.isArray(payload.messages)) {
+        payload.messages = truncateContextResultMessages(payload.messages, maxChars);
+    }
+    if (Array.isArray(payload.input)) {
+        payload.input = truncateResponsesInputResultItems(payload.input, maxChars);
+    }
+}
+function applySourceContextBlock(payload, deps) {
+    if (!deps.isAutoActive())
+        return;
+    const sourceContextBlock = deps.renderSourceContextBlock();
+    if (!sourceContextBlock)
+        return;
+    Object.assign(payload, injectSourceContextBlockIntoPayload(payload, sourceContextBlock));
+}
+function applyServiceTier(payload, modelId, deps) {
+    if (!modelId)
+        return;
+    const tier = deps.getEffectiveServiceTier();
+    if (!tier || !deps.supportsServiceTier(modelId))
+        return;
+    payload.service_tier = tier;
+}

package/dist/resources/extensions/gsd/pull-request-process.js

@@ -0,0 +1,13 @@
+// Project/App: gsd-pi
+// File Purpose: Process-level pull request policy for GSD-generated PRs.
+import { createDraftPR } from "./git-service.js";
+import { buildPrEvidence, } from "./pr-evidence.js";
+export function buildPullRequestEvidence(input) {
+    return buildPrEvidence({
+        ...input,
+        aiAssisted: false,
+    });
+}
+export function createDraftPullRequestFromEvidence(basePath, milestoneId, evidence, options, deps = { createDraftPR }) {
+    return deps.createDraftPR(basePath, milestoneId, evidence.title, evidence.body, options);
+}

package/dist/resources/extensions/gsd/quality-gate-closure.js

@@ -0,0 +1,109 @@
+// Project/App: gsd-pi
+// File Purpose: Canonical quality-gate closure from durable DB and artifact evidence.
+import { existsSync, readFileSync } from "node:fs";
+import { extractSection } from "./files.js";
+import { getGateDefinition } from "./gate-registry.js";
+import { getMilestoneSlices, getPendingGates, saveGateResult } from "./gsd-db.js";
+import { resolveSliceFile, resolveTaskFile } from "./paths.js";
+const GATE_SECTION_HEADINGS = {
+    Q3: ["Threat Surface", "Abuse Surface"],
+    Q4: ["Requirement Impact", "Broken Promises"],
+    Q5: ["Failure Modes"],
+    Q6: ["Load Profile"],
+    Q7: ["Negative Tests"],
+    Q8: ["Operational Readiness"],
+};
+function readFile(path) {
+    if (!path || !existsSync(path))
+        return null;
+    return readFileSync(path, "utf-8");
+}
+function firstSection(content, gateId) {
+    if (!content)
+        return null;
+    for (const heading of GATE_SECTION_HEADINGS[gateId] ?? []) {
+        const section = extractSection(content, heading);
+        if (section)
+            return section;
+    }
+    return null;
+}
+function evidenceArtifactContent(row, basePath) {
+    const def = getGateDefinition(row.gate_id);
+    switch (def?.ownerTurn) {
+        case "gate-evaluate":
+            return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "PLAN"));
+        case "execute-task":
+            return readFile(resolveTaskFile(basePath, row.milestone_id, row.slice_id, row.task_id, "SUMMARY"));
+        case "complete-slice":
+            return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "SUMMARY"));
+        default:
+            return null;
+    }
+}
+function closureEvidence(row, options) {
+    const def = getGateDefinition(row.gate_id);
+    if (!def)
+        return null;
+    if (def.ownerTurn === "validate-milestone" && options.milestoneValidationPassed) {
+        return {
+            verdict: "pass",
+            rationale: `${def.promptSection} covered by passing milestone validation`,
+            findings: "",
+        };
+    }
+    if (!options.artifactBasePath)
+        return null;
+    const section = firstSection(evidenceArtifactContent(row, options.artifactBasePath), row.gate_id);
+    if (section) {
+        return {
+            verdict: "pass",
+            rationale: `${def.promptSection} evidence found in durable artifact`,
+            findings: section,
+        };
+    }
+    if (!options.milestoneValidationPassed)
+        return null;
+    return {
+        verdict: "omitted",
+        rationale: `${def.promptSection} has no durable artifact section; milestone validation passed`,
+        findings: "",
+    };
+}
+function closeGate(row, evidence) {
+    saveGateResult({
+        milestoneId: row.milestone_id,
+        sliceId: row.slice_id,
+        gateId: row.gate_id,
+        taskId: row.task_id,
+        verdict: evidence.verdict,
+        rationale: evidence.rationale,
+        findings: evidence.findings,
+    });
+}
+export function closeQualityGatesFromEvidence(milestoneId, options = {}) {
+    const repaired = [];
+    const unresolved = [];
+    for (const slice of getMilestoneSlices(milestoneId)) {
+        const sliceId = slice.id;
+        for (const row of getPendingGates(milestoneId, sliceId)) {
+            if (!getGateDefinition(row.gate_id)) {
+                unresolved.push(row);
+                continue;
+            }
+            const evidence = closureEvidence(row, options);
+            if (!evidence) {
+                unresolved.push(row);
+                continue;
+            }
+            closeGate(row, evidence);
+            repaired.push({
+                gateId: row.gate_id,
+                sliceId: row.slice_id,
+                ...(row.task_id ? { taskId: row.task_id } : {}),
+                verdict: evidence.verdict,
+            });
+        }
+    }
+    return { repaired, unresolved };
+}

package/dist/resources/extensions/gsd/question-transport.js

@@ -0,0 +1,86 @@
+// Project/App: gsd-pi
+// File Purpose: Resolve how workflow units should ask the user for input.
+import { parseMcpToolName, toMcpToolName } from "./mcp-tool-name.js";
+function isWorkflowMcpServerName(serverName) {
+    const normalized = serverName.toLowerCase();
+    return normalized === "gsd" || normalized.includes("workflow");
+}
+export function usesWorkflowMcpTransport(authMode, baseUrl) {
+    return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
+}
+export function hasAskUserQuestionsTool(activeTools) {
+    return activeTools.some((toolName) => {
+        if (toolName === "ask_user_questions")
+            return true;
+        const mcp = parseMcpToolName(toolName);
+        if (!mcp)
+            return false;
+        if (mcp.toolName === "ask_user_questions")
+            return true;
+        return mcp.toolName === "*" && isWorkflowMcpServerName(mcp.serverName);
+    });
+}
+function workflowMcpStructuredQuestionsEnabled(env = process.env) {
+    const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS?.trim().toLowerCase();
+    return value !== "0" && value !== "false" && value !== "off";
+}
+export function resolveQuestionTransport(options) {
+    const questionToolAvailable = hasAskUserQuestionsTool(options.activeTools);
+    const usesWorkflowMcp = usesWorkflowMcpTransport(options.authMode, options.baseUrl);
+    if (!questionToolAvailable) {
+        return {
+            structuredQuestionsAvailable: "false",
+            questionToolAvailable,
+            usesWorkflowMcp,
+            reason: "question-tool-missing",
+        };
+    }
+    if (options.authMode === "externalCli" && !workflowMcpStructuredQuestionsEnabled(options.env)) {
+        return {
+            structuredQuestionsAvailable: "false",
+            questionToolAvailable,
+            usesWorkflowMcp,
+            reason: "workflow-mcp-disabled",
+        };
+    }
+    return {
+        structuredQuestionsAvailable: "true",
+        questionToolAvailable,
+        usesWorkflowMcp,
+        reason: "question-tool-available",
+    };
+}
+export function supportsStructuredQuestions(activeTools, options = {}) {
+    return resolveQuestionTransport({
+        ...options,
+        activeTools,
+    }).structuredQuestionsAvailable === "true";
+}
+export function resolveWorkflowQuestionToolSurface(options) {
+    const questionToolName = options.workflowServerName && !options.workflowExplicitlyBlocked
+        ? toMcpToolName(options.workflowServerName, "ask_user_questions")
+        : undefined;
+    const activeTools = [
+        ...options.exactWorkflowMcpTools,
+        ...options.workflowMcpTools,
+        ...(questionToolName ? [questionToolName] : []),
+    ];
+    const transport = resolveQuestionTransport({
+        activeTools,
+        authMode: "externalCli",
+        baseUrl: "local://claude-code",
+        env: options.env,
+    });
+    const exactQuestionToolAllowed = !!questionToolName && options.exactWorkflowMcpTools.includes(questionToolName);
+    const workflowQuestionsEnabled = transport.structuredQuestionsAvailable === "true" &&
+        (options.workflowMcpTools.length > 0 || exactQuestionToolAllowed);
+    const disallowedTools = options.workflowServerName && transport.questionToolAvailable && !workflowQuestionsEnabled
+        ? [toMcpToolName(options.workflowServerName, "ask_user_questions")]
+        : [];
+    return {
+        ...transport,
+        questionToolName,
+        workflowQuestionsEnabled,
+        disallowedTools,
+    };
+}

package/dist/resources/extensions/gsd/roadmap-slices.js

@@ -191,9 +191,15 @@ export function parseRoadmapSlices(content) {
             const riskMatch = rest.match(/`risk:(\w+)`/);
             const risk = (riskMatch ? riskMatch[1] : "low");
             const depsMatch = rest.match(/`depends:\[([^\]]*)\]`/);
-            const depends = depsMatch && depsMatch[1].trim()
-                ? expandDependencies(depsMatch[1].split(",").map(s => s.trim()))
+            // Recovery fallback: double-bracket form `[[id]]` from serialized bracket-wrapped IDs
+            const fallbackDepsMatch = depsMatch ? null : rest.match(/`depends:\[(\[(?:[^\]]*)\](?:,\[(?:[^\]]*)\])*)\]`/);
+            const rawDepContent = (depsMatch ?? fallbackDepsMatch)?.[1] ?? "";
+            const SLICE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
+            const RANGE_RE = /^[A-Za-z]+\d+(?:-|\.\.)[A-Za-z]+\d+$/;
+            const rawDepParts = rawDepContent.trim()
+                ? rawDepContent.replace(/\[|\]/g, "").split(",").map(s => s.trim()).filter(s => SLICE_ID_RE.test(s) || RANGE_RE.test(s))
                 : [];
+            const depends = expandDependencies(rawDepParts);
             // ADR-011: the renderer writes a `[sketch]` badge for sketch slices.
             // Parse it back so the is_sketch flag survives a markdown → DB re-import
             // (e.g. /gsd recover); otherwise the flag was silently lost.

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

@@ -19,7 +19,8 @@ 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";
-import { runWorktreePostCreateHook, syncGsdStateToWorktree } from "./auto-worktree.js";
+import { runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { writeSessionStatus, } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";
 import { getErrorMessage } from "./error-utils.js";
@@ -108,7 +109,7 @@ function createSliceWorktree(basePath, milestoneId, sliceId) {
     if (hookError) {
         throw new Error(`slice worktree post-create hook failed (${wtName}): ${hookError}`);
     }
-    syncGsdStateToWorktree(basePath, wtPath);
+    syncGsdStateToWorktreeByScope(scopeMilestone(createWorkspace(basePath), milestoneId), scopeMilestone(createWorkspace(wtPath), milestoneId));
     if (!existsSync(join(wtPath, ".gsd"))) {
         throw new Error(`slice worktree preflight failed (${wtName}): missing .gsd in worktree`);
     }

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

@@ -18,8 +18,10 @@ import { logWarning } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
 import { detectPendingEscalation } from './escalation.js';
 import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifier.js';
-import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, getRequirementCounts, getLatestAssessmentByScope, getPendingGateCountForTurn, } from './gsd-db.js';
+import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, getRequirementCounts, getLatestAssessmentByScope, getPendingGateCountForTurn, } from './gsd-db.js';
+import { wasWorkflowDatabaseOpenAttempted } from './db-workspace.js';
 import { formatCompletePhaseNextAction, countUnmappedActiveRequirements } from './requirements-backlog.js';
+import { classifyMilestoneReadiness, readinessNeedsDiscussion, } from './milestone-readiness.js';
 function formatNeedsAttentionBlocker(milestoneId) {
     return [
         `Milestone ${milestoneId} is blocked because milestone validation returned needs-attention.`,
@@ -301,7 +303,7 @@ export async function deriveState(basePath, opts) {
         _telemetry.dbDeriveCount++;
     }
     else {
-        if (wasDbOpenAttempted()) {
+        if (wasWorkflowDatabaseOpenAttempted()) {
             logWarning("state", "DB unavailable — refusing implicit markdown state derivation");
         }
         result = {
@@ -396,6 +398,12 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
         const title = stripMilestonePrefix(m.title) || m.id;
         const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
         const hasDraftContext = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
+        const readiness = classifyMilestoneReadiness({
+            status: m.status,
+            hasContext,
+            hasDraftContext,
+            sliceCount: slices.length,
+        });
         if (!activeMilestoneFound) {
             const deps = m.depends_on;
             const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
@@ -403,9 +411,9 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
                 registry.push({ id: m.id, title, status: 'pending', dependsOn: deps });
                 continue;
             }
-            if (m.status === 'queued' && slices.length === 0 && !hasContext) {
+            if (readiness.kind === 'queued-shell') {
                 if (!firstDeferredQueuedShell) {
-                    firstDeferredQueuedShell = { id: m.id, title, deps, hasDraftContext };
+                    firstDeferredQueuedShell = { id: m.id, title, deps, hasDraftContext: readiness.hasDraftContext };
                 }
                 registry.push({ id: m.id, title, status: 'pending', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
                 continue;
@@ -417,7 +425,7 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
                 registry.push({ id: m.id, title, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
                 continue;
             }
-            if ((m.status === 'needs-discussion' && !hasContext) || hasDraftContext)
+            if (readinessNeedsDiscussion(readiness))
                 activeMilestoneHasDraft = true;
             activeMilestone = { id: m.id, title };
             activeMilestoneSlices = slices;

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

@@ -46,6 +46,13 @@
      For simple projects or scripts:
      - Executable verification commands (bash assertions, curl checks, etc.) are sufficient
 
+     For browser-facing web apps (React, Next, Vue, Vite, static HTML, etc.):
+     - Prefer `npx playwright test <spec>` in Verification when `@playwright/test` exists
+     - If Playwright is not set up yet, the first UI slice should add `playwright.config.ts`,
+       a minimal smoke spec (for example `e2e/smoke.spec.ts`), and a safe verify command
+     - Slice closeout UAT must declare `browser-executable` or `runtime-executable` — not
+       `artifact-driven` — when checks navigate to localhost or exercise the live UI
+
      If the project has no test framework and the work is non-trivial,
      the first task should set one up. A test runner costs 2 minutes
      and pays for itself immediately.

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

@@ -20,6 +20,7 @@
 
 - **Complexity:** {{simple | complex}}
 - **Why:** {{one-line rationale citing the signals that decided it}}
+- **Web stack:** {{browser-facing framework or "not a web UI" — e.g. Next.js + Playwright, static HTML, N/A for CLI/API-only}}
 
 ## Current State
 

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

@@ -42,7 +42,7 @@
 - Contract verification: {{tests / shell verifiers / fixtures / artifact checks}}
 - Integration verification: {{real subsystem interaction that must be exercised, or none}}
 - Operational verification: {{service lifecycle / restart / reconnect / supervision / deploy-install behavior, or none}}
-- UAT / human verification: {{what needs real human judgment, or none}}
+- UAT / human verification: {{what needs real human judgment, or none — for web apps prefer browser-executable / runtime-executable Playwright checks over deferring UI proof to humans}}
 
 ## Milestone Definition of Done
 

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

@@ -5,9 +5,13 @@
 
 ## UAT Type
 
-- UAT mode: {{artifact-driven | live-runtime | human-experience | mixed}}
+- UAT mode: {{artifact-driven | browser-executable | runtime-executable | live-runtime | human-experience | mixed}}
 - Why this mode is sufficient: {{reason}}
 
+<!-- Web apps: never use artifact-driven when steps open a browser, navigate to localhost,
+     or capture screenshots. Use browser-executable (browser_* tools) or runtime-executable
+     (npx playwright test). Name dev-server preconditions below. -->
+
 ## Preconditions
 
 {{whatMustBeTrueBeforeTesting — server running, data seeded, etc.}}

package/dist/resources/extensions/gsd/tool-contract.js

@@ -4,6 +4,17 @@ import { resolveManifest, } from "./unit-context-manifest.js";
 import { getRequiredWorkflowToolsForAutoUnit } from "./workflow-mcp.js";
 import { getUnitToolSurfaceContract } from "./unit-tool-contracts.js";
 import { WHOLE_FILE_OBSERVATION_MAX_BYTES, WHOLE_FILE_OBSERVATION_MAX_LINES, } from "./source-observations.js";
+export function compileUnitContextContract(unitType) {
+    const manifest = resolveManifest(unitType);
+    if (!manifest) {
+        return {
+            ok: false,
+            reason: "unknown-unit-type",
+            detail: `No Unit manifest is registered for ${unitType}`,
+        };
+    }
+    return { ok: true, contract: buildPromptContextContract(unitType, manifest) };
+}
 export function compileUnitToolContract(unitType) {
     const manifest = resolveManifest(unitType);
     const surfaceContract = getUnitToolSurfaceContract(unitType);
@@ -25,6 +36,7 @@ export function compileUnitToolContract(unitType) {
             detail: `${unitType} has no closeout workflow tool`,
         };
     }
+    const promptContext = buildPromptContextContract(unitType, manifest);
     return {
         ok: true,
         contract: {
@@ -33,10 +45,8 @@ export function compileUnitToolContract(unitType) {
             toolsPolicy: manifest.tools,
             requiredWorkflowTools,
             forbiddenWorkflowTools,
-            promptObligations: [
-                `context-mode:${manifest.contextMode}`,
-                `tools-policy:${manifest.tools.mode}`,
-            ],
+            promptObligations: promptContext.obligations,
+            promptContext,
             validationRules: [
                 "unit-manifest-present",
                 "workflow-tool-surface-present",
@@ -44,15 +54,49 @@ export function compileUnitToolContract(unitType) {
                 ...(unitType === "execute-task" ? ["source-observation-contract-present"] : []),
             ],
             closeoutTools,
-            sourceObservations: sourceObservationContractForUnit(unitType),
+            sourceObservations: promptContext.sourceObservations,
             artifacts: {
-                inline: manifest.artifacts.inline,
-                excerpt: manifest.artifacts.excerpt,
-                onDemand: manifest.artifacts.onDemand,
+                inline: promptContext.artifacts.inline,
+                excerpt: promptContext.artifacts.excerpt,
+                onDemand: promptContext.artifacts.onDemand,
             },
         },
     };
 }
+function buildPromptContextContract(unitType, manifest) {
+    const sourceObservations = sourceObservationContractForUnit(unitType);
+    return {
+        unitType,
+        contextMode: manifest.contextMode,
+        toolsPolicy: manifest.tools,
+        obligations: promptContextObligations(manifest, sourceObservations),
+        sourceObservations,
+        artifacts: {
+            inline: manifest.artifacts.inline,
+            excerpt: manifest.artifacts.excerpt,
+            onDemand: manifest.artifacts.onDemand,
+            computed: manifest.artifacts.computed ?? [],
+            prepend: manifest.prepend ?? [],
+        },
+        maxSystemPromptChars: manifest.maxSystemPromptChars,
+    };
+}
+function promptContextObligations(manifest, sourceObservations) {
+    const obligations = [
+        `context-mode:${manifest.contextMode}`,
+        `tools-policy:${manifest.tools.mode}`,
+        artifactObligation("context-inline", manifest.artifacts.inline),
+        artifactObligation("context-excerpt", manifest.artifacts.excerpt),
+        artifactObligation("context-on-demand", manifest.artifacts.onDemand),
+    ];
+    if (sourceObservations.mode !== "none") {
+        obligations.push(`source-observations:${sourceObservations.mode}`);
+    }
+    return obligations;
+}
+function artifactObligation(label, artifacts) {
+    return `${label}:${artifacts.length > 0 ? artifacts.join(",") : "none"}`;
+}
 function sourceObservationContractForUnit(unitType) {
     if (unitType !== "execute-task")
         return { mode: "none" };