@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

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/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

@@ -10,6 +10,26 @@ const APPROVAL_QUESTION_RE = /\b(?:confirm|confirmation|approve|approval|approve
 const APPROVAL_RIGHT_QUESTION_RE = /\b(?:does|do|is|are|was|were|did)\b[^\n?]{0,120}\bright\b/i;
 const APPROVAL_CHANGE_QUESTION_RE = /\b(?:anything\s+else|anything|something)\s+to\s+(?:adjust|add|remove|reclassify)\b/i;
 const RESEARCH_DECISION_QUESTION_RE = /\b(?:research|skip)\b/i;
+function extractVisibleTextFromMessage(msg) {
+    if (!msg || typeof msg !== "object")
+        return "";
+    const content = msg.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const typed = block;
+        if (typed.type === "text" && typeof typed.text === "string") {
+            parts.push(typed.text);
+        }
+        // thinking blocks intentionally excluded — they are internal reasoning, not user-visible
+    }
+    return parts.join("\n");
+}
 function extractTextFromMessage(msg) {
     if (!msg || typeof msg !== "object")
         return "";
@@ -26,6 +46,9 @@ function extractTextFromMessage(msg) {
         if (typed.type === "text" && typeof typed.text === "string") {
             parts.push(typed.text);
         }
+        if (typed.type === "thinking" && typeof typed.thinking === "string") {
+            parts.push(typed.thinking);
+        }
     }
     return parts.join("\n");
 }
@@ -44,6 +67,21 @@ export function lastAssistantText(messages) {
     }
     return "";
 }
+function lastAssistantVisibleText(messages) {
+    if (!Array.isArray(messages))
+        return "";
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== "object")
+            continue;
+        if (msg.role !== "assistant")
+            continue;
+        const text = extractVisibleTextFromMessage(msg).trim();
+        if (text)
+            return text;
+    }
+    return "";
+}
 function anyMessageMatches(messages, pattern) {
     if (!Array.isArray(messages))
         return false;
@@ -52,7 +90,7 @@ function anyMessageMatches(messages, pattern) {
             return false;
         if (msg.role === "user")
             return false;
-        return pattern.test(extractTextFromMessage(msg));
+        return pattern.test(extractVisibleTextFromMessage(msg));
     });
 }
 function hasApprovalQuestion(text) {
@@ -117,7 +155,7 @@ export function isAwaitingUserInput(messages) {
         return true;
     if (anyMessageMatches(messages, REMOTE_QUESTION_FAILURE_RE))
         return true;
-    const text = lastAssistantText(messages);
+    const text = lastAssistantVisibleText(messages);
     if (!text)
         return false;
     if (APPROVAL_WAIT_RE.test(text))
@@ -132,13 +170,36 @@ export function isAwaitingApprovalBoundary(messages) {
         return true;
     if (anyMessageMatches(messages, REMOTE_QUESTION_FAILURE_RE))
         return true;
-    const text = lastAssistantText(messages);
+    const text = lastAssistantVisibleText(messages);
     if (!text)
         return false;
     if (APPROVAL_WAIT_RE.test(text))
         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;
@@ -146,7 +207,7 @@ export function shouldPauseForUserApprovalQuestion(unitType, messages) {
         return true;
     if (anyMessageMatches(messages, REMOTE_QUESTION_FAILURE_RE))
         return true;
-    const text = lastAssistantText(messages);
+    const text = lastAssistantVisibleText(messages);
     if (!text)
         return false;
     if (APPROVAL_WAIT_RE.test(text))

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");
+}

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -1,8 +1,12 @@
 import { execSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
+import { basename, dirname, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
+import { mcpToolMatchesBaseName } from "./mcp-tool-name.js";
+import { supportsStructuredQuestions, usesWorkflowMcpTransport, } from "./question-transport.js";
+import { WORKFLOW_TOOL_SURFACE_NAMES, isWorkflowToolSurfaceName, } from "./workflow-tool-surface.js";
+export { supportsStructuredQuestions, usesWorkflowMcpTransport };
 /** Session cwd may be a milestone worktree; MCP config and server discovery use the project root. */
 export function resolveWorkflowMcpProjectRoot(sessionCwd) {
     let resolved;
@@ -19,72 +23,9 @@ export function resolveWorkflowMcpProjectRoot(sessionCwd) {
     }
     return resolved;
 }
-const MCP_WORKFLOW_TOOL_SURFACE = new Set([
-    "gsd_cancel",
-    "gsd_captures",
-    "ask_user_questions",
-    "gsd_capture_thought",
-    "gsd_doctor",
-    "gsd_execute",
-    "gsd_memory_query",
-    "gsd_memory_graph",
-    "gsd_decision_save",
-    "gsd_exec",
-    "gsd_exec_search",
-    "gsd_graph",
-    "gsd_history",
-    "gsd_knowledge",
-    "gsd_progress",
-    "gsd_query",
-    "gsd_resume",
-    "gsd_result",
-    "gsd_resolve_blocker",
-    "gsd_roadmap",
-    "gsd_status",
-    "gsd_complete_milestone",
-    "gsd_complete_task",
-    "gsd_complete_slice",
-    "gsd_generate_milestone_id",
-    "gsd_journal_query",
-    "gsd_milestone_complete",
-    "gsd_milestone_generate_id",
-    "gsd_milestone_reopen",
-    "gsd_checkpoint_db",
-    "gsd_milestone_plan",
-    "gsd_milestone_status",
-    "gsd_milestone_validate",
-    "gsd_plan_task",
-    "gsd_plan_milestone",
-    "gsd_plan_slice",
-    "gsd_replan_slice",
-    "gsd_reassess_roadmap",
-    "gsd_reopen_milestone",
-    "gsd_reopen_slice",
-    "gsd_reopen_task",
-    "gsd_requirement_save",
-    "gsd_requirement_update",
-    "gsd_roadmap_reassess",
-    "gsd_save_decision",
-    "gsd_save_gate_result",
-    "gsd_save_requirement",
-    "gsd_save_summary",
-    "gsd_skip_slice",
-    "gsd_slice_plan",
-    "gsd_slice_replan",
-    "gsd_slice_complete",
-    "gsd_slice_reopen",
-    "gsd_summary_save",
-    "gsd_task_plan",
-    "gsd_task_complete",
-    "gsd_task_reopen",
-    "gsd_update_requirement",
-    "gsd_uat_exec",
-    "gsd_uat_result_save",
-    "gsd_validate_milestone",
-]);
 /** Workflow MCP tools are validated by transport compatibility, not pi tool-compat profiles. */
 export function isWorkflowMcpSurfaceTool(toolName) {
-    return MCP_WORKFLOW_TOOL_SURFACE.has(toolName);
+    return isWorkflowToolSurfaceName(toolName);
 }
 function parseLookupOutput(output) {
     return output
@@ -239,8 +180,12 @@ function getBundledWorkflowWriteGateModulePath() {
 }
 function getResolveTsHookPath() {
     const repoRoot = findGsdPiRepoRoot(dirname(fileURLToPath(import.meta.url)));
+    const sourceRepoRoot = repoRoot && basename(repoRoot) === "dist-test" ? dirname(repoRoot) : repoRoot;
     return firstExistingPath([
-        ...(repoRoot
+        ...(sourceRepoRoot
+            ? [resolve(sourceRepoRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs")]
+            : []),
+        ...(repoRoot && repoRoot !== sourceRepoRoot
             ? [resolve(repoRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs")]
             : []),
         resolve(fileURLToPath(new URL("./tests/resolve-ts.mjs", import.meta.url))),
@@ -355,45 +300,13 @@ export function getRequiredWorkflowToolsForGuidedUnit(unitType) {
 export function getRequiredWorkflowToolsForAutoUnit(unitType) {
     return getRequiredWorkflowToolsForUnit(unitType);
 }
-export function usesWorkflowMcpTransport(authMode, baseUrl) {
-    return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
-}
-function hasAskUserQuestionsTool(activeTools) {
-    return activeTools.some((toolName) => {
-        if (toolName === "ask_user_questions")
-            return true;
-        if (!toolName.startsWith("mcp__"))
-            return false;
-        const toolSeparator = toolName.indexOf("__", "mcp__".length);
-        return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === "ask_user_questions";
-    });
-}
 function hasRequiredTool(requiredTool, activeTools) {
     return activeTools.some((toolName) => {
         if (toolName === requiredTool)
             return true;
-        if (!toolName.startsWith("mcp__"))
-            return false;
-        const toolSeparator = toolName.indexOf("__", "mcp__".length);
-        return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === requiredTool;
+        return mcpToolMatchesBaseName(toolName, requiredTool);
     });
 }
-function workflowMcpStructuredQuestionsOptIn(env = process.env) {
-    const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS;
-    return value === "1" || value === "true";
-}
-export function supportsStructuredQuestions(activeTools, options = {}) {
-    if (!hasAskUserQuestionsTool(activeTools))
-        return false;
-    if (usesWorkflowMcpTransport(options.authMode, options.baseUrl)) {
-        // Claude Code local workflow-MCP exposes ask_user_questions, but form
-        // elicitation can return an immediate cancel outside GSD's chat turn. Keep
-        // checkpoints in plain chat unless a caller deliberately opts into testing
-        // that transport.
-        return workflowMcpStructuredQuestionsOptIn(options.env);
-    }
-    return true;
-}
 export function getWorkflowTransportSupportError(provider, requiredTools, options = {}) {
     if (!provider || requiredTools.length === 0)
         return null;
@@ -410,12 +323,12 @@ export function getWorkflowTransportSupportError(provider, requiredTools, option
     }
     const uniqueRequired = [...new Set(requiredTools)];
     const missing = (options.activeTools && options.activeTools.length > 0)
-        ? uniqueRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools))
-        : uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
+        ? uniqueRequired.filter((tool) => !isWorkflowToolSurfaceName(tool) && !hasRequiredTool(tool, options.activeTools))
+        : uniqueRequired.filter((tool) => !isWorkflowToolSurfaceName(tool));
     if (missing.length === 0)
         return null;
     if (options.activeTools && options.activeTools.length > 0) {
         return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the active runtime toolset currently exposes only ${options.activeTools.slice().sort().join(", ")}.`;
     }
-    return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the workflow MCP transport currently exposes only ${Array.from(MCP_WORKFLOW_TOOL_SURFACE).sort().join(", ")}.`;
+    return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the workflow MCP transport currently exposes only ${[...WORKFLOW_TOOL_SURFACE_NAMES].sort().join(", ")}.`;
 }

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -2,7 +2,8 @@ import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { readEvents, findForkPoint, getSessionId } from "./workflow-events.js";
-import { transaction, updateTaskStatus, updateSliceStatus, updateMilestoneStatus, getSliceTasks, insertMilestone, getMilestoneSlices, insertVerificationEvidence, upsertDecision, openDatabase, setTaskBlockerDiscovered, insertOrIgnoreSlice, insertOrIgnoreTask, } from "./gsd-db.js";
+import { transaction, updateTaskStatus, updateSliceStatus, updateMilestoneStatus, getSliceTasks, insertMilestone, getMilestoneSlices, insertVerificationEvidence, upsertDecision, setTaskBlockerDiscovered, insertOrIgnoreSlice, insertOrIgnoreTask, } from "./gsd-db.js";
+import { openWorkflowDatabasePath } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache, resolveGsdPathContract } from "./paths.js";
@@ -415,7 +416,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     mkdirSync(join(mainBasePath, ".gsd"), { recursive: true });
     atomicWriteSync(join(mainBasePath, ".gsd", "event-log.jsonl"), logContent);
     // Step 8: Replay into DB (wrapped in a transaction by replayEvents)
-    openDatabase(resolveGsdPathContract(mainBasePath).projectDb);
+    openWorkflowDatabasePath(resolveGsdPathContract(mainBasePath).projectDb);
     replayEvents(merged);
     // Step 9: Write manifest
     try {
@@ -548,7 +549,7 @@ pick) {
     const targetBaseEvents = pick === "main" ? wtBaseEvents : mainBaseEvents;
     writeEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
     // Replay resolved events through the DB (updates DB state)
-    openDatabase(resolveGsdPathContract(basePath).projectDb);
+    openWorkflowDatabasePath(resolveGsdPathContract(basePath).projectDb);
     replayEvents(eventsToReplay);
     invalidateStateCache();
     clearPathCache();

package/dist/resources/extensions/gsd/workflow-tool-surface.js

@@ -0,0 +1,46 @@
+// Project/App: gsd-pi
+// File Purpose: Adapts shared workflow tool contracts into the extension runtime surface.
+import { CANONICAL_WORKFLOW_TOOL_NAMES as CONTRACT_CANONICAL_WORKFLOW_TOOL_NAMES, WORKFLOW_TOOL_ALIAS_NAMES as CONTRACT_WORKFLOW_TOOL_ALIAS_NAMES, WORKFLOW_TOOL_CONTRACTS as CONTRACT_WORKFLOW_TOOL_CONTRACTS, WORKFLOW_TOOL_NAMES as CONTRACT_WORKFLOW_TOOL_NAMES, } from "@opengsd/contracts";
+import { stripMcpToolPrefix } from "./mcp-tool-name.js";
+export const WORKFLOW_TOOL_CONTRACTS = CONTRACT_WORKFLOW_TOOL_CONTRACTS;
+export const CANONICAL_WORKFLOW_TOOL_NAMES = CONTRACT_CANONICAL_WORKFLOW_TOOL_NAMES;
+export const WORKFLOW_TOOL_ALIAS_NAMES = CONTRACT_WORKFLOW_TOOL_ALIAS_NAMES;
+export const DB_WORKFLOW_TOOL_NAMES = CONTRACT_WORKFLOW_TOOL_NAMES;
+export const WORKFLOW_TOOL_ALIAS_PAIRS = WORKFLOW_TOOL_CONTRACTS.flatMap((tool) => tool.aliases.map((alias) => ({ canonical: tool.canonicalName, alias })));
+export const WORKFLOW_TOOL_ALIAS_TO_CANONICAL = Object.fromEntries(WORKFLOW_TOOL_ALIAS_PAIRS.map(({ alias, canonical }) => [alias, canonical]));
+const WORKFLOW_MCP_ADAPTER_TOOL_NAMES = [
+    "gsd_cancel",
+    "gsd_captures",
+    "ask_user_questions",
+    "gsd_doctor",
+    "gsd_execute",
+    "gsd_graph",
+    "gsd_history",
+    "gsd_knowledge",
+    "gsd_progress",
+    "gsd_query",
+    "gsd_result",
+    "gsd_resolve_blocker",
+    "gsd_roadmap",
+    "gsd_status",
+];
+export const WORKFLOW_TOOL_SURFACE_NAMES = [
+    ...WORKFLOW_MCP_ADAPTER_TOOL_NAMES,
+    ...DB_WORKFLOW_TOOL_NAMES,
+];
+const WORKFLOW_TOOL_SURFACE_NAME_SET = new Set(WORKFLOW_TOOL_SURFACE_NAMES);
+export { stripMcpToolPrefix } from "./mcp-tool-name.js";
+export function canonicalWorkflowSurfaceToolName(toolName) {
+    const baseName = stripMcpToolPrefix(toolName);
+    return WORKFLOW_TOOL_ALIAS_TO_CANONICAL[baseName] ?? baseName;
+}
+export function isWorkflowSurfaceAliasTool(toolName) {
+    const baseName = stripMcpToolPrefix(toolName);
+    return WORKFLOW_TOOL_ALIAS_TO_CANONICAL[baseName] !== undefined;
+}
+export function isWorkflowToolSurfaceName(toolName) {
+    return WORKFLOW_TOOL_SURFACE_NAME_SET.has(stripMcpToolPrefix(toolName));
+}
+export function aliasesForWorkflowTool(canonicalName) {
+    return WORKFLOW_TOOL_CONTRACTS.find((tool) => tool.canonicalName === canonicalName)?.aliases ?? [];
+}

package/dist/resources/extensions/gsd/workspace-git-guard.js

@@ -12,6 +12,8 @@ export function isWorkspaceGitAllowedCommand(trimmed) {
     const [name, subcommand] = command.split(/\s+/, 2);
     if (name === "doctor")
         return true;
+    if (name === "forensics")
+        return true;
     if (name === "closeout" || command.startsWith("closeout"))
         return true;
     if (name === "dispatch") {