@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.65546769

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

@@ -3,9 +3,14 @@
 // GSD Extension — State Derivation
 // DB-authoritative runtime derivation with explicit legacy filesystem fallback.
 // Pure TypeScript, zero Pi dependencies.
+// Pre-migration fallback ONLY (ADR-017): deriveState must work on projects
+// whose DB does not exist yet (before md-importer runs), so it parses markdown
+// projections when `isDbAvailable()` is false or the DB has no rows. Once the
+// DB is populated, decision reads go through gsd-db queries — these parsers
+// must never be consulted when DB data is present.
 import { parseRoadmap, parsePlan, } from './parsers-legacy.js';
 import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn, } from './files.js';
-import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
+import { buildMilestoneFileName, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
 import { isClosedStatus, isDeferredStatus } from './status-guards.js';
@@ -18,28 +23,11 @@ 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, getSlicesByMilestoneIds, getSliceTasks, getReplanHistory, getSlice, getRequirementCounts, getLatestAssessmentByScope, getPendingGateCountForTurn, setMilestoneQueueOrder, } from './gsd-db.js';
+import { openExistingWorkflowDatabase, wasWorkflowDatabaseOpenAttempted } from './db-workspace.js';
 import { formatCompletePhaseNextAction, countUnmappedActiveRequirements } from './requirements-backlog.js';
-function formatNeedsAttentionBlocker(milestoneId) {
-    return [
-        `Milestone ${milestoneId} is blocked because milestone validation returned needs-attention.`,
-        `Fix options:`,
-        `1. Review the validation details: \`/gsd status\``,
-        `2. If you fixed the missing evidence or issue, re-run milestone validation: \`/gsd validate-milestone\``,
-        `3. If the finding is acceptable, override it: \`/gsd verdict pass --rationale "why this is okay"\``,
-        `4. If this should wait, defer it explicitly: \`/gsd park ${milestoneId}\``,
-        `After validation or override passes, run \`/gsd auto\` to complete and merge the milestone.`,
-    ].join("\n");
-}
-function formatNeedsRemediationBlocker(milestoneId) {
-    return [
-        `Milestone ${milestoneId} is blocked because milestone validation returned needs-remediation, but all slices are complete.`,
-        `Fix options:`,
-        `1. Run \`/gsd dispatch reassess\` to add remediation slices, then run \`/gsd auto\``,
-        `2. If the finding is acceptable, override it: \`/gsd verdict pass --rationale "why this is okay"\``,
-        `3. If this should wait, defer it explicitly: \`/gsd park ${milestoneId}\``,
-    ].join("\n");
-}
+import { classifyMilestoneReadiness, readinessNeedsDiscussion, } from './milestone-readiness.js';
+import { needsAttentionBlockerGuidance as formatNeedsAttentionBlocker, needsRemediationBlockerGuidance as formatNeedsRemediationBlocker, } from './guidance.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -201,6 +189,36 @@ async function loadRecentDecisions(basePath) {
 export function invalidateStateCache() {
     _stateCache = null;
 }
+function syncQueueOrderProjectionToDb(basePath) {
+    const queueOrder = loadQueueOrder(basePath);
+    if (!queueOrder)
+        return;
+    const currentIds = getAllMilestones().map((m) => m.id);
+    const desiredIds = sortByQueueOrder(currentIds, queueOrder);
+    if (currentIds.length === desiredIds.length && currentIds.every((id, i) => id === desiredIds[i]))
+        return;
+    setMilestoneQueueOrder(desiredIds);
+}
+function ensureExistingWorkflowDbOpen(basePath) {
+    const opened = isDbAvailable() || openExistingWorkflowDatabase(basePath).ok;
+    if (opened)
+        syncQueueOrderProjectionToDb(basePath);
+    return opened;
+}
+function buildDbUnavailableState() {
+    return {
+        activeMilestone: null,
+        activeSlice: null,
+        activeTask: null,
+        phase: "pre-planning",
+        recentDecisions: [],
+        blockers: ["DB unavailable — runtime markdown state derivation is disabled"],
+        nextAction: "Open or create the canonical GSD database before deriving workflow state. If this project only has markdown state, run /gsd migrate explicitly.",
+        registry: [],
+        requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+        progress: { milestones: { done: 0, total: 0 } },
+    };
+}
 /**
  * Returns the ID of the first incomplete milestone, or null if all are complete.
  */
@@ -231,6 +249,7 @@ export async function getActiveMilestoneId(basePath) {
     }
     // DB-first: query milestones table for the first non-complete, non-parked milestone
     if (isDbAvailable()) {
+        syncQueueOrderProjectionToDb(basePath);
         const allMilestones = getAllMilestones();
         if (allMilestones.length > 0) {
             for (const m of allMilestones) {
@@ -294,6 +313,7 @@ export async function deriveState(basePath, opts) {
     // DB-backed derivation is authoritative whenever the DB is open. Runtime
     // degrade must not infer state from ROADMAP.md, PLAN.md, SUMMARY.md,
     // REQUIREMENTS.md, or flag files.
+    ensureExistingWorkflowDbOpen(basePath);
     if (isDbAvailable()) {
         const stopDbTimer = debugTime("derive-state-db");
         result = await deriveStateFromDb(basePath, opts?.projectRootForReads ?? basePath);
@@ -301,21 +321,10 @@ export async function deriveState(basePath, opts) {
         _telemetry.dbDeriveCount++;
     }
     else {
-        if (wasDbOpenAttempted()) {
+        if (wasWorkflowDatabaseOpenAttempted()) {
             logWarning("state", "DB unavailable — refusing implicit markdown state derivation");
         }
-        result = {
-            activeMilestone: null,
-            activeSlice: null,
-            activeTask: null,
-            phase: "pre-planning",
-            recentDecisions: [],
-            blockers: ["DB unavailable — runtime markdown state derivation is disabled"],
-            nextAction: "Open or create the canonical GSD database before deriving workflow state. If this project only has markdown state, run /gsd migrate explicitly.",
-            registry: [],
-            requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
-            progress: { milestones: { done: 0, total: 0 } },
-        };
+        result = buildDbUnavailableState();
     }
     result.recentDecisions = await loadRecentDecisions(cacheKey);
     stopTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
@@ -371,6 +380,12 @@ function buildCompletenessSet(basePath, milestones) {
     }
     return { completeMilestoneIds, parkedMilestoneIds };
 }
+function milestoneArtifactExistsInResolvedDir(milestoneDir, milestoneId, suffix) {
+    if (!milestoneDir)
+        return false;
+    const flatPath = join(milestoneDir, buildMilestoneFileName(milestoneId, suffix));
+    return existsSync(flatPath) || resolveFile(milestoneDir, milestoneId, suffix) !== null;
+}
 async function buildRegistryAndFindActive(basePath, milestones, completeMilestoneIds, parkedMilestoneIds) {
     const registry = [];
     let activeMilestone = null;
@@ -378,12 +393,16 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
     let activeMilestoneFound = false;
     let activeMilestoneHasDraft = false;
     let firstDeferredQueuedShell = null;
+    const activeMilestoneIds = milestones
+        .filter((m) => !parkedMilestoneIds.has(m.id))
+        .map((m) => m.id);
+    const slicesByMilestone = getSlicesByMilestoneIds(activeMilestoneIds);
     for (const m of milestones) {
         if (parkedMilestoneIds.has(m.id)) {
             registry.push({ id: m.id, title: stripMilestonePrefix(m.title) || m.id, status: 'parked' });
             continue;
         }
-        const slices = getMilestoneSlices(m.id);
+        const slices = slicesByMilestone.get(m.id) ?? [];
         // DB-authoritative completeness (#4179): only trust completeMilestoneIds,
         // which is itself derived from DB status. SUMMARY-file presence alone must
         // not imply completion.
@@ -394,8 +413,15 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
         }
         const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
         const title = stripMilestonePrefix(m.title) || m.id;
-        const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
-        const hasDraftContext = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
+        const milestoneDir = resolveMilestonePath(basePath, m.id);
+        const hasContext = milestoneArtifactExistsInResolvedDir(milestoneDir, m.id, "CONTEXT");
+        const hasDraftContext = !hasContext && milestoneArtifactExistsInResolvedDir(milestoneDir, 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 +429,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 +443,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;
@@ -581,6 +607,9 @@ function checkReplanTrigger(basePath, milestoneId, sliceId) {
     return !!sliceRow?.replan_triggered_at;
 }
 export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
+    if (!ensureExistingWorkflowDbOpen(basePath)) {
+        return buildDbUnavailableState();
+    }
     const requirements = getRequirementCounts();
     const allMilestones = getAllMilestones();
     const milestoneLock = getRequestedMilestoneLock();

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

@@ -1,16 +1,64 @@
 /**
- * Status predicates for GSD state-machine guards.
+ * Status predicates and the canonical status vocabulary for GSD state-machine
+ * guards (ADR-030).
  *
- * The DB stores status as free-form strings. Three values indicate
- * "closed": "complete" (canonical), "done" (legacy / alias),
- * "closed" (legacy/imported), and
- * "skipped" (user-directed skip via rethink or backtrack).
- * Every inline `status === "complete" || status === "done"` should
- * use isClosedStatus() instead.
+ * The DB column is free-form `string` so legacy/imported rows still load. Three
+ * raw values besides canonical "complete"/"skipped" indicate "closed": "done"
+ * (legacy alias), "closed" (legacy/imported), and "skipped" (user-directed skip
+ * via rethink or backtrack). `RAW_CLOSED_STATUSES` is the single source for both
+ * `isClosedStatus()` and the SQL terminal-status fragment
+ * (`db/sql-constants.ts` derives `TERMINAL_STATUS_SQL` from it), replacing the
+ * prior independent definitions.
+ *
+ * `toStatus()` is the single seam where a free-form string becomes the canonical
+ * `Status` vocabulary; the Status Transition Core writes canonical, so the store
+ * converges over time without a forced migration.
+ */
+/**
+ * Canonical, normalized entity-status vocabulary across milestones, slices, and
+ * tasks — the single source for both the `Status` type and the runtime
+ * membership set. The in-memory domain speaks `Status`; the DB column stays
+ * free-form.
+ */
+export const CANONICAL_STATUSES = [
+    "pending", "queued", "active", "parked", "in_progress", "blocked", "complete", "skipped", "deferred",
+];
+const CANONICAL_STATUS_SET = new Set(CANONICAL_STATUSES);
+/**
+ * Raw status values that mean a unit is closed — the single source of truth.
+ * Includes legacy/imported aliases ("done", "closed") alongside canonical
+ * "complete"/"skipped" because the DB column is free-form and older rows /
+ * imports still carry them. Order matters: `TERMINAL_STATUS_SQL` is derived
+ * from this array verbatim.
+ */
+export const RAW_CLOSED_STATUSES = ["complete", "done", "skipped", "closed"];
+const RAW_CLOSED_SET = new Set(RAW_CLOSED_STATUSES);
+/** Free-form aliases mapped to their canonical Status on read. */
+const ALIAS_TO_CANONICAL = {
+    done: "complete",
+    closed: "complete",
+    planned: "pending",
+    "in-progress": "in_progress",
+};
+/**
+ * Normalize a free-form DB status string into the canonical `Status`
+ * vocabulary. Maps known aliases (done/closed → complete, planned → pending,
+ * in-progress → in_progress). An unrecognized/legacy value is **quarantined** —
+ * preserved verbatim rather than silently remapped to a wrong canonical state —
+ * so reads never fail and reconciliation/telemetry can surface it.
  */
+export function toStatus(raw) {
+    const value = raw.trim();
+    if (CANONICAL_STATUS_SET.has(value))
+        return value;
+    const alias = ALIAS_TO_CANONICAL[value];
+    if (alias)
+        return alias;
+    return value;
+}
 /** Returns true when a milestone, slice, or task status indicates closure. */
 export function isClosedStatus(status) {
-    return status === "complete" || status === "done" || status === "skipped" || status === "closed";
+    return RAW_CLOSED_SET.has(status);
 }
 /** Returns true when a slice status indicates it was deferred by a decision. */
 export function isDeferredStatus(status) {

package/dist/resources/extensions/gsd/stop-notice.js

@@ -0,0 +1,57 @@
+// Project/App: gsd-pi
+// File Purpose: Stop Notice module — single owner of the auto/step-mode
+// stop/pause notice vocabulary. Both sides of the wire live here: the
+// formatters that produce the canonical prefixes (used by stopAuto/pauseAuto)
+// and the classifiers that recognize them (used by the headless host to pick
+// exit codes). Wording changes in this file keep emitter and detector in
+// lockstep; round-trip tests enforce it.
+/** A reason string of the form "Blocked: …" marks a blocked stop. */
+export function isBlockedStopReason(reason) {
+    return /^Blocked:\s*/i.test(reason ?? "");
+}
+/** Strip the "Blocked: " marker for display. */
+export function stopNoticeDisplayReason(reason) {
+    return (reason ?? "").replace(/^Blocked:\s*/i, "").trim();
+}
+export function stopNoticeKind(reason) {
+    return isBlockedStopReason(reason) ? "blocked" : "stopped";
+}
+/** Canonical stop-notice prefix: "Auto-mode blocked — reason" / "Auto-mode stopped". */
+export function formatStopNoticePrefix(reason) {
+    const displayReason = stopNoticeDisplayReason(reason);
+    const prefix = stopNoticeKind(reason) === "blocked" ? "Auto-mode blocked" : "Auto-mode stopped";
+    return displayReason ? `${prefix} — ${displayReason}` : prefix;
+}
+// ─── Classification (headless host side) ────────────────────────────────
+// The canonical lowercase prefixes the headless event loop recognizes in
+// notify messages. Emitters above and ad-hoc emitters elsewhere must start
+// their terminal notices with one of these.
+export const PAUSED_NOTICE_PREFIXES = ["auto-mode paused", "step-mode paused"];
+export const TERMINAL_NOTICE_PREFIXES = [
+    "auto-mode stopped",
+    "step-mode stopped",
+    "auto-mode complete",
+    "no active milestone",
+    "auto-mode idle",
+];
+/** Manual-resolution notices emitted before auto-mode can formally pause/stop. */
+export function isManualResolutionNotice(message) {
+    return (message.includes("resolve manually and re-run /gsd auto") ||
+        message.includes("resolve conflicts manually and run /gsd auto to resume") ||
+        message.includes("resolve and run /gsd auto to resume"));
+}
+export function isPauseNotice(message) {
+    return PAUSED_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix));
+}
+export function isTerminalNotice(message) {
+    return TERMINAL_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix));
+}
+/** Pauses that do not require operator intervention in headless mode. */
+export function isNonBlockingPauseNotice(message) {
+    return message.includes("idempotent advance: unit already active");
+}
+export function isBlockedNoticeMessage(message) {
+    return (message.includes("blocked:") ||
+        (isPauseNotice(message) && !isNonBlockingPauseNotice(message)) ||
+        isManualResolutionNotice(message));
+}

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

@@ -1,21 +1,14 @@
 // GSD Extension — Advisory Sync Lock
 // Prevents concurrent worktree syncs from colliding via a simple file lock.
 // Stale locks (mtime > 60s, owner PID confirmed dead) are overridden. Lock
-// acquisition waits up to 5 seconds then skips non-fatally.
+// acquisition skips non-fatally when a live lock is already held.
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeSync } from "node:fs";
 import { dirname, join } from "node:path";
 const STALE_THRESHOLD_MS = 60_000; // 60 seconds
-const DEFAULT_TIMEOUT_MS = 5_000; // 5 seconds
-const SPIN_INTERVAL_MS = 100; // 100ms polling interval
-// SharedArrayBuffer for synchronous sleep via Atomics.wait
-const SLEEP_BUFFER = new SharedArrayBuffer(4);
-const SLEEP_VIEW = new Int32Array(SLEEP_BUFFER);
+const DEFAULT_TIMEOUT_MS = 0; // fail fast; sync waits block the JS event loop
 function lockFilePath(basePath) {
     return join(basePath, ".gsd", "sync.lock");
 }
-function sleepSync(ms) {
-    Atomics.wait(SLEEP_VIEW, 0, 0, ms);
-}
 /** True if the given PID is alive in the current process namespace. */
 function isPidAlive(pid) {
     try {
@@ -62,7 +55,7 @@ function tryCreateLockFile(lp, payload) {
 }
 /**
  * Acquire an advisory sync lock for the given basePath.
- * Returns { acquired: true } on success, { acquired: false } after timeout.
+ * Returns { acquired: true } on success, { acquired: false } when a live lock is held.
  *
  * Replaces a non-atomic `existsSync` + `atomicWriteSync` (write-temp+rename,
  * which is not exclusive-create) sequence that allowed two callers to both
@@ -73,10 +66,13 @@ function tryCreateLockFile(lp, payload) {
  * before stealing — prevents a slow event-loop pause (>60s under heavy I/O)
  * from making a legitimately-held lock appear stale and get stolen.
  * (Issue #4980 M-concurrency-3)
+ *
+ * Contended live locks fail fast. A synchronous wait here would freeze timers,
+ * I/O, and UI work on Node's single JS thread. The timeout argument remains
+ * accepted for compatibility but is intentionally not used for sync waiting.
  */
-export function acquireSyncLock(basePath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS) {
     const lp = lockFilePath(basePath);
-    const deadline = Date.now() + timeoutMs;
     const lockData = JSON.stringify({ pid: process.pid, acquired_at: new Date().toISOString() }, null, 2);
     while (true) {
         // First try the fast path: atomic create. No check-then-write race.
@@ -88,7 +84,7 @@ export function acquireSyncLock(basePath, timeoutMs = DEFAULT_TIMEOUT_MS) {
         catch {
             /* unexpected — fall through to retry */
         }
-        // File exists. Decide whether to steal (stale + owner dead) or wait.
+        // File exists. Decide whether to steal (stale + owner dead) or skip.
         let canSteal = false;
         try {
             const stat = statSync(lp);
@@ -122,11 +118,8 @@ export function acquireSyncLock(basePath, timeoutMs = DEFAULT_TIMEOUT_MS) {
             // Loop back to retry create.
             continue;
         }
-        // Lock is held and not stale (or owner is alive) — wait or give up.
-        if (Date.now() >= deadline) {
-            return { acquired: false };
-        }
-        sleepSync(SPIN_INTERVAL_MS);
+        // Lock is held and not stale (or owner is alive) — skip non-fatally.
+        return { acquired: false };
     }
 }
 /**

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

@@ -1,9 +1,31 @@
 // Project/App: gsd-pi
 // File Purpose: ADR-015 Tool Contract module for Unit prompt, policy, and tool parity.
 import { resolveManifest, } from "./unit-context-manifest.js";
-import { getRequiredWorkflowToolsForAutoUnit } from "./workflow-mcp.js";
-import { getUnitToolSurfaceContract } from "./unit-tool-contracts.js";
+import { getWorkflowTransportSupportError, } from "./workflow-mcp.js";
+import { getRequiredWorkflowToolsForUnit, 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 getUnitWorkflowDispatchReadinessError(input) {
+    return getWorkflowTransportSupportError(input.provider, getRequiredWorkflowToolsForUnit(input.unitType), {
+        projectRoot: input.projectRoot,
+        env: input.env,
+        surface: input.surface,
+        unitType: input.unitType,
+        authMode: input.authMode,
+        baseUrl: input.baseUrl,
+        activeTools: input.activeTools,
+    });
+}
 export function compileUnitToolContract(unitType) {
     const manifest = resolveManifest(unitType);
     const surfaceContract = getUnitToolSurfaceContract(unitType);
@@ -14,7 +36,7 @@ export function compileUnitToolContract(unitType) {
             detail: `No Unit manifest is registered for ${unitType}`,
         };
     }
-    const requiredWorkflowTools = getRequiredWorkflowToolsForAutoUnit(unitType);
+    const requiredWorkflowTools = getRequiredWorkflowToolsForUnit(unitType);
     const forbiddenWorkflowTools = Object.entries(surfaceContract?.forbiddenGsdTools ?? {})
         .map(([name, reason]) => ({ name, reason }));
     const closeoutTools = requiredWorkflowTools.filter((tool) => /^gsd_(?:task|slice|milestone|complete|validate|save|summary|uat)/.test(tool));
@@ -25,6 +47,7 @@ export function compileUnitToolContract(unitType) {
             detail: `${unitType} has no closeout workflow tool`,
         };
     }
+    const promptContext = buildPromptContextContract(unitType, manifest);
     return {
         ok: true,
         contract: {
@@ -33,10 +56,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 +65,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" };

package/dist/resources/extensions/gsd/tool-presentation-plan.js

@@ -1,7 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Resolve phase-aware tool surfaces for GSD model presentations.
 import { RUN_UAT_BROWSER_TOOL_NAMES, RUN_UAT_READ_ONLY_TOOL_NAMES, RUN_UAT_TOOL_PRESENTATION_PLAN_ID, RUN_UAT_WORKFLOW_TOOL_NAMES, } from "./unit-tool-contracts.js";
+import { toMcpToolName } from "./mcp-tool-name.js";
+import { createToolSurfaceSnapshot } from "./tool-surface-snapshot.js";
 import { uatTypeIncludesBrowser } from "./uat-policy.js";
+import { canonicalWorkflowToolName } from "./engine-hook-contract.js";
 export { RUN_UAT_BROWSER_TOOL_NAMES, RUN_UAT_READ_ONLY_TOOL_NAMES, RUN_UAT_TOOL_PRESENTATION_PLAN_ID, RUN_UAT_WORKFLOW_TOOL_NAMES, } from "./unit-tool-contracts.js";
 export const RUN_UAT_FORBIDDEN_TOOL_NAMES = [
     "edit",
@@ -21,43 +24,12 @@ export const RUN_UAT_CLAUDE_NATIVE_TOOL_NAMES = [
     "Glob",
     "Grep",
 ];
-const WORKFLOW_ALIAS_TO_CANONICAL = {
-    gsd_save_decision: "gsd_decision_save",
-    gsd_update_requirement: "gsd_requirement_update",
-    gsd_save_requirement: "gsd_requirement_save",
-    gsd_save_summary: "gsd_summary_save",
-    gsd_generate_milestone_id: "gsd_milestone_generate_id",
-    gsd_milestone_plan: "gsd_plan_milestone",
-    gsd_slice_plan: "gsd_plan_slice",
-    gsd_task_plan: "gsd_plan_task",
-    gsd_slice_replan: "gsd_replan_slice",
-    gsd_complete_slice: "gsd_slice_complete",
-    gsd_milestone_complete: "gsd_complete_milestone",
-    gsd_milestone_validate: "gsd_validate_milestone",
-    gsd_roadmap_reassess: "gsd_reassess_roadmap",
-    gsd_complete_task: "gsd_task_complete",
-    gsd_reopen_task: "gsd_task_reopen",
-    gsd_reopen_slice: "gsd_slice_reopen",
-    gsd_reopen_milestone: "gsd_milestone_reopen",
-};
-export function canonicalWorkflowToolName(toolName) {
-    const mcp = parseMcpToolName(toolName);
-    const baseName = mcp?.tool ?? toolName;
-    return WORKFLOW_ALIAS_TO_CANONICAL[baseName] ?? baseName;
-}
-export function parseMcpToolName(toolName) {
-    if (!toolName.startsWith("mcp__"))
-        return null;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    if (toolSeparator < 0)
-        return null;
-    return {
-        server: toolName.slice("mcp__".length, toolSeparator),
-        tool: toolName.slice(toolSeparator + 2),
-    };
-}
+// Normalizer seam lives in engine-hook-contract.ts; re-exported here for
+// existing presentation importers (uat-run.ts).
+export { canonicalWorkflowToolName };
+export { parseMcpToolName } from "./mcp-tool-name.js";
 export function toWorkflowMcpToolName(serverName, toolName) {
-    return `mcp__${serverName}__${canonicalWorkflowToolName(toolName)}`;
+    return toMcpToolName(serverName, canonicalWorkflowToolName(toolName));
 }
 function dedupe(values) {
     return [...new Set(values)];
@@ -134,6 +106,14 @@ export function resolveToolPresentationPlan(options) {
             ? toWorkflowMcpToolName(workflowServerName, name)
             : name)
         : allowedToolNames;
+    const toolSurface = createToolSurfaceSnapshot({
+        source: "presentation-plan",
+        phase: options.phase,
+        modelFacingToolNames: options.availableToolNames ?? requested,
+        registeredToolNames: options.availableToolNames ?? requested,
+        scopedToolNames: allowedToolNames,
+        presentedToolNames,
+    });
     if (options.phase === "run-uat") {
         for (const forbidden of RUN_UAT_FORBIDDEN_TOOL_NAMES) {
             addBlockedTool(blockedToolNames, forbidden, "forbidden during run-uat");
@@ -148,5 +128,6 @@ export function resolveToolPresentationPlan(options) {
         blockedToolNames,
         aliases,
         diagnostics: [],
+        toolSurface,
     };
 }