@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.75048e7

package/dist/resources/extensions/gsd/verdict-parser.js

@@ -5,7 +5,62 @@
  * (e.g. `passed` → `pass`) are applied consistently across the codebase.
  */
 import { extractUatType } from "./files.js";
+import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
+import { parse as parseYaml } from "yaml";
+function normalizeVerdict(value) {
+    if (typeof value !== "string")
+        return undefined;
+    let verdict = value.trim().toLowerCase();
+    if (!verdict)
+        return undefined;
+    if (verdict === "passed")
+        verdict = "pass";
+    return verdict;
+}
+function getCaseInsensitive(obj, key) {
+    const lowerKey = key.toLowerCase();
+    for (const [candidate, value] of Object.entries(obj)) {
+        if (candidate.toLowerCase() === lowerKey)
+            return value;
+    }
+    return undefined;
+}
 // ── Verdict extraction ──────────────────────────────────────────────────
+/**
+ * Extract and normalize the frontmatter `verdict` value.
+ *
+ * Supports both top-level `verdict` and the hook outcome shape
+ * `outcome.verdict`. Returns `undefined` when frontmatter is absent or has no
+ * verdict field.
+ */
+export function extractFrontmatterVerdict(content) {
+    const [frontmatterLines] = splitFrontmatter(content);
+    if (!frontmatterLines)
+        return undefined;
+    try {
+        const parsed = parseYaml(frontmatterLines.join("\n"));
+        if (parsed && typeof parsed === "object") {
+            const root = parsed;
+            const topLevel = normalizeVerdict(getCaseInsensitive(root, "verdict"));
+            if (topLevel)
+                return topLevel;
+            const outcome = getCaseInsensitive(root, "outcome");
+            if (outcome && typeof outcome === "object") {
+                const nested = normalizeVerdict(getCaseInsensitive(outcome, "verdict"));
+                if (nested)
+                    return nested;
+            }
+        }
+    }
+    catch {
+        // Fall through to the permissive parser used by legacy frontmatter paths.
+    }
+    const frontmatter = parseFrontmatterMap(frontmatterLines);
+    const topLevel = normalizeVerdict(getCaseInsensitive(frontmatter, "verdict"));
+    if (topLevel)
+        return topLevel;
+    return undefined;
+}
 /**
  * Extract and normalize the `verdict` value from YAML frontmatter.
  *
@@ -17,25 +72,14 @@ import { extractUatType } from "./files.js";
  */
 export function extractVerdict(content) {
     // Primary: YAML frontmatter verdict (canonical format)
-    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    if (fmMatch) {
-        const verdictMatch = fmMatch[1].match(/verdict:\s*([\w-]+)/i);
-        if (verdictMatch) {
-            let v = verdictMatch[1].toLowerCase();
-            if (v === "passed")
-                v = "pass";
-            return v;
-        }
-        return undefined;
-    }
+    const [frontmatterLines] = splitFrontmatter(content);
+    if (frontmatterLines)
+        return extractFrontmatterVerdict(content);
     // Fallback: detect verdict in markdown body (LLM manual writes, #2960).
     // Matches patterns like: **Verdict:** PASS, **Verdict:** ✅ PASS, **Verdict** needs-remediation
     const bodyMatch = content.match(/\*\*Verdict:?\*\*\s*(?:✅\s*)?(\w[\w-]*)/i);
     if (bodyMatch) {
-        let v = bodyMatch[1].toLowerCase();
-        if (v === "passed")
-            v = "pass";
-        return v;
+        return normalizeVerdict(bodyMatch[1]);
     }
     return undefined;
 }

package/dist/resources/extensions/gsd/verification-gate.js

@@ -246,6 +246,76 @@ function hasUnsafeShellSyntax(cmd) {
     }
     return false;
 }
+function splitLeadingShellWords(cmd) {
+    const words = [];
+    let current = "";
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let i = 0; i < cmd.length; i += 1) {
+        const ch = cmd[i];
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\" && !inSingle) {
+            escaped = true;
+            continue;
+        }
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === "\"" && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (!inSingle && !inDouble) {
+            if (/\s/.test(ch)) {
+                if (current) {
+                    words.push(current);
+                    current = "";
+                }
+                continue;
+            }
+            if ([";", "|", "&", "<", ">"].includes(ch)) {
+                break;
+            }
+        }
+        current += ch;
+    }
+    if (current) {
+        words.push(current);
+    }
+    return words;
+}
+function isCountFlag(token) {
+    return (token === "--count" ||
+        token.startsWith("--count=") ||
+        token === "--count-matches" ||
+        token.startsWith("--count-matches=") ||
+        /^-[A-Za-z]*c[A-Za-z]*$/.test(token));
+}
+function countSearchWarning(command, exitCode) {
+    if (exitCode !== 1)
+        return null;
+    const trimmed = command.trim();
+    if (trimmed.startsWith("!"))
+        return null;
+    const [tool, ...args] = splitLeadingShellWords(trimmed);
+    if (tool !== "grep" && tool !== "rg")
+        return null;
+    if (!args.some(isCountFlag))
+        return null;
+    return `verification-gate: warning: '${tool} -c' returns exit 1 when count=0; for absence checks use '! ${tool} -q ...' instead.`;
+}
+function appendStderrWarning(stderr, warning) {
+    if (!warning)
+        return stderr;
+    const trimmed = stderr.trimEnd();
+    return trimmed ? `${trimmed}\n${warning}` : warning;
+}
 /**
  * Known executable first-tokens that are safe to run.
  * Lowercase commands, common build/test tools, and npm/yarn/pnpm invocations.
@@ -411,11 +481,12 @@ export function runVerificationGate(options) {
             exitCode = result.status ?? 1;
             stderr = truncate(result.stderr, MAX_OUTPUT_BYTES);
         }
+        const warning = countSearchWarning(command, exitCode);
         checks.push({
             command,
             exitCode,
             stdout: truncate(result.stdout, MAX_OUTPUT_BYTES),
-            stderr,
+            stderr: truncate(appendStderrWarning(stderr, warning), MAX_OUTPUT_BYTES),
             durationMs,
         });
     }

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

@@ -2,7 +2,7 @@ import { execSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { dirname, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { RUN_UAT_WORKFLOW_TOOL_NAMES } from "./tool-presentation-plan.js";
+import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
 /** Session cwd may be a milestone worktree; MCP config and server discovery use the project root. */
 export function resolveWorkflowMcpProjectRoot(sessionCwd) {
     let resolved;
@@ -350,82 +350,10 @@ export function buildWorkflowMcpServers(projectRoot = process.cwd(), env = proce
     };
 }
 export function getRequiredWorkflowToolsForGuidedUnit(unitType) {
-    switch (unitType) {
-        case "discuss-project":
-            return ["ask_user_questions", "gsd_summary_save"];
-        case "discuss-requirements":
-            return ["ask_user_questions", "gsd_requirement_save", "gsd_summary_save"];
-        case "research-decision":
-            return ["ask_user_questions"];
-        case "discuss-milestone":
-            return [
-                "gsd_summary_save",
-                "gsd_requirement_save",
-                "gsd_requirement_update",
-                "gsd_plan_milestone",
-                "gsd_milestone_generate_id",
-            ];
-        case "discuss-slice":
-            return ["gsd_summary_save"];
-        case "research-milestone":
-        case "research-slice":
-            return ["gsd_summary_save"];
-        case "plan-milestone":
-            return ["gsd_plan_milestone"];
-        case "plan-slice":
-            return ["gsd_plan_slice"];
-        case "execute-task":
-            return ["gsd_task_complete"];
-        case "complete-slice":
-            return ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"];
-        default:
-            return [];
-    }
+    return getRequiredWorkflowToolsForUnit(unitType);
 }
 export function getRequiredWorkflowToolsForAutoUnit(unitType) {
-    switch (unitType) {
-        case "discuss-project":
-            return ["ask_user_questions", "gsd_summary_save"];
-        case "discuss-requirements":
-            return ["ask_user_questions", "gsd_requirement_save", "gsd_summary_save"];
-        case "research-decision":
-            return ["ask_user_questions"];
-        case "discuss-milestone":
-            return [
-                "gsd_summary_save",
-                "gsd_requirement_save",
-                "gsd_requirement_update",
-                "gsd_plan_milestone",
-                "gsd_milestone_generate_id",
-            ];
-        case "research-milestone":
-        case "research-slice":
-            return ["gsd_summary_save"];
-        case "run-uat":
-            return [...RUN_UAT_WORKFLOW_TOOL_NAMES];
-        case "plan-milestone":
-            return ["gsd_plan_milestone"];
-        case "plan-slice":
-            return ["gsd_plan_slice"];
-        case "execute-task":
-        case "execute-task-simple":
-        case "reactive-execute":
-            return ["gsd_task_complete"];
-        case "complete-slice":
-            return ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"];
-        case "replan-slice":
-            return ["gsd_replan_slice"];
-        case "reassess-roadmap":
-            return ["gsd_milestone_status", "gsd_reassess_roadmap"];
-        case "gate-evaluate":
-            return ["gsd_save_gate_result"];
-        case "validate-milestone":
-            return ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap"];
-        case "complete-milestone":
-            return ["gsd_milestone_status", "gsd_complete_milestone"];
-        default:
-            return [];
-    }
+    return getRequiredWorkflowToolsForUnit(unitType);
 }
 export function usesWorkflowMcpTransport(authMode, baseUrl) {
     return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");

package/dist/resources/extensions/shared/gsd-browser-cli.js

@@ -0,0 +1,145 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const GSD_BROWSER_MCP_SERVER_NAME = "gsd-browser";
+function parseJsonEnv(env, name) {
+    const raw = env[name];
+    if (!raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${name}`);
+    }
+}
+function sanitizeSessionSegment(value) {
+    return value
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+}
+function compareSemverLocal(a, b) {
+    const left = a.split(".").map(Number);
+    const right = b.split(".").map(Number);
+    for (let index = 0; index < Math.max(left.length, right.length); index++) {
+        const leftValue = left[index] || 0;
+        const rightValue = right[index] || 0;
+        if (leftValue > rightValue)
+            return 1;
+        if (leftValue < rightValue)
+            return -1;
+    }
+    return 0;
+}
+function parseGsdBrowserVersion(output) {
+    return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+}
+function resolveBundledGsdBrowserPackageVersion() {
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return typeof pkg.version === "string" ? parseGsdBrowserVersion(pkg.version) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePathGsdBrowserVersion(env) {
+    const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
+    if (explicit)
+        return parseGsdBrowserVersion(explicit);
+    try {
+        return parseGsdBrowserVersion(execFileSync("gsd-browser", ["--version"], {
+            encoding: "utf-8",
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+function shouldPreferPathGsdBrowser(env) {
+    const pathVersion = resolvePathGsdBrowserVersion(env);
+    if (!pathVersion)
+        return false;
+    const bundledVersion = resolveBundledGsdBrowserPackageVersion();
+    return !bundledVersion || compareSemverLocal(pathVersion, bundledVersion) > 0;
+}
+export function resolveBundledGsdBrowserCliPath(env = process.env) {
+    const explicit = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+    if (explicit)
+        return explicit;
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
+        const candidate = resolve(packageJsonPath, "..", "bin", "gsd-browser");
+        if (existsSync(candidate))
+            return candidate;
+    }
+    catch {
+        // Fall through to path candidates for source/dist layouts.
+    }
+    const candidates = [
+        resolve(fileURLToPath(new URL("../../../../node_modules/@opengsd/gsd-browser/bin/gsd-browser", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../node_modules/.bin/gsd-browser", import.meta.url))),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function buildGsdBrowserSessionName(projectRoot, suffix) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const base = sanitizeSessionSegment(basename(resolvedProjectRoot)) || "project";
+    const hash = createHash("sha1").update(resolvedProjectRoot).digest("hex").slice(0, 8);
+    const cleanSuffix = suffix ? sanitizeSessionSegment(suffix) : "";
+    return cleanSuffix ? `gsd-${base}-${hash}-${cleanSuffix}` : `gsd-${base}-${hash}`;
+}
+export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env, options = {}) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
+    const explicitArgs = parseJsonEnv(env, "GSD_BROWSER_MCP_ARGS");
+    const explicitEnv = parseJsonEnv(env, "GSD_BROWSER_MCP_ENV");
+    const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
+    const explicitCliPath = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+    const preferPathCli = !explicitCommand && !explicitCliPath && shouldPreferPathGsdBrowser(env);
+    const bundledCliPath = !explicitCommand && !explicitCliPath && !preferPathCli
+        ? resolveBundledGsdBrowserCliPath(env)
+        : null;
+    const sessionName = options.sessionName?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot, options.sessionSuffix);
+    const command = explicitCommand
+        || explicitCliPath
+        || (preferPathCli ? "gsd-browser" : undefined)
+        || (bundledCliPath ? process.execPath : undefined)
+        || "gsd-browser";
+    const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
+        ? explicitArgs.map(String)
+        : [
+            ...(bundledCliPath ? [bundledCliPath] : []),
+            "mcp",
+            "--session",
+            sessionName,
+            "--identity-scope",
+            "project",
+            "--identity-project",
+            resolvedProjectRoot,
+        ];
+    const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
+    return {
+        serverName,
+        command,
+        args,
+        cwd,
+        ...(explicitEnv ? { env: explicitEnv } : {}),
+        projectRoot: resolvedProjectRoot,
+        sessionName,
+    };
+}

package/dist/rtk.d.ts

@@ -40,6 +40,12 @@ export interface ValidateRtkBinaryOptions {
     spawnSyncImpl?: typeof spawnSync;
     env?: NodeJS.ProcessEnv;
 }
-export declare function validateRtkBinary(binaryPath: string, options?: ValidateRtkBinaryOptions): boolean;
+export type ValidateRtkBinaryResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: string;
+};
+export declare function validateRtkBinary(binaryPath: string, options?: ValidateRtkBinaryOptions): ValidateRtkBinaryResult;
 export declare function ensureRtkAvailable(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;
 export declare function bootstrapRtk(options?: EnsureRtkOptions): Promise<EnsureRtkResult>;

package/dist/rtk.js

@@ -162,19 +162,28 @@ export function rewriteCommandWithRtk(command, options = {}) {
     const rewritten = (result.stdout ?? "").trimEnd();
     return rewritten || command;
 }
+function trimSpawnOutput(output) {
+    return output?.toString().trim() ?? "";
+}
 export function validateRtkBinary(binaryPath, options = {}) {
     const run = options.spawnSyncImpl ?? spawnSync;
     const result = run(binaryPath, ["rewrite", "git status"], {
         encoding: "utf-8",
         env: buildRtkEnv(options.env ?? process.env),
-        stdio: ["ignore", "pipe", "ignore"],
+        stdio: ["ignore", "pipe", "pipe"],
         timeout: RTK_REWRITE_TIMEOUT_MS,
     });
     if (result.error)
-        return false;
-    if (result.status !== 0)
-        return false;
-    return (result.stdout ?? "").trim() === "rtk git status";
+        return { valid: false, error: result.error.message };
+    if (result.status !== 0) {
+        const stderr = trimSpawnOutput(result.stderr);
+        return { valid: false, error: stderr || `exit code ${result.status ?? "unknown"}` };
+    }
+    const stdout = trimSpawnOutput(result.stdout);
+    if (stdout !== "rtk git status") {
+        return { valid: false, error: stdout ? `unexpected output: ${stdout}` : "unexpected empty output" };
+    }
+    return { valid: true };
 }
 export async function ensureRtkAvailable(options = {}) {
     const env = options.env ?? process.env;
@@ -190,12 +199,18 @@ export async function ensureRtkAvailable(options = {}) {
     }
     const targetDir = options.targetDir ?? getManagedRtkDir(env);
     const managedPath = getManagedRtkPath(process.platform, targetDir);
-    if (existsSync(managedPath) && validateRtkBinary(managedPath, { env })) {
-        return { enabled: true, supported: true, available: true, source: "managed", binaryPath: managedPath };
+    if (existsSync(managedPath)) {
+        const managedValidation = validateRtkBinary(managedPath, { env });
+        if (managedValidation.valid) {
+            return { enabled: true, supported: true, available: true, source: "managed", binaryPath: managedPath };
+        }
     }
     const systemPath = resolveSystemRtkPath(options.pathValue ?? getPathValue(env));
-    if (systemPath && validateRtkBinary(systemPath, { env })) {
-        return { enabled: true, supported: true, available: true, source: "system", binaryPath: systemPath };
+    if (systemPath) {
+        const systemValidation = validateRtkBinary(systemPath, { env });
+        if (systemValidation.valid) {
+            return { enabled: true, supported: true, available: true, source: "system", binaryPath: systemPath };
+        }
     }
     const version = options.releaseVersion ?? RTK_VERSION;
     const assetName = resolveRtkAssetName(process.platform, osArch(), version);
@@ -241,9 +256,10 @@ export async function ensureRtkAvailable(options = {}) {
         if (process.platform !== "win32") {
             chmodSync(managedPath, 0o755);
         }
-        if (!validateRtkBinary(managedPath, { env })) {
+        const downloadedValidation = validateRtkBinary(managedPath, { env });
+        if (!downloadedValidation.valid) {
             rmSync(managedPath, { force: true });
-            throw new Error("downloaded RTK binary failed validation");
+            throw new Error(`downloaded RTK binary failed validation: ${downloadedValidation.error}`);
         }
         options.log?.(`installed RTK ${version} to ${managedPath}`);
         return { enabled: true, supported: true, available: true, source: "downloaded", binaryPath: managedPath };

package/dist/update-check.d.ts

@@ -1,5 +1,9 @@
 import { isPnpmInstall } from './resources/shared/package-manager-detection.js';
 export { isPnpmInstall };
+export declare const GSD_PI_PACKAGE_NAME = "@opengsd/gsd-pi";
+export declare const GSD_BROWSER_PACKAGE_NAME = "@opengsd/gsd-browser";
+export declare const DEFAULT_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
+export declare const GSD_BROWSER_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-browser/latest";
 interface UpdateCheckCache {
     lastCheck: number;
     latestVersion: string;
@@ -13,6 +17,14 @@ export declare function readUpdateCache(cachePath?: string, packageName?: string
 export declare function writeUpdateCache(cache: Omit<UpdateCheckCache, 'packageName'> & {
     packageName?: string;
 }, cachePath?: string, packageName?: string): void;
+export declare function resolveInstalledPackageVersion(packageName: string): string | null;
+/**
+ * Resolves the gsd-browser version from PATH (via `gsd-browser --version`).
+ * Respects GSD_BROWSER_PATH_VERSION env override for testing.
+ * Returns null if gsd-browser is not on PATH or times out.
+ */
+export declare function resolveGsdBrowserPathVersion(env?: NodeJS.ProcessEnv): string | null;
+export declare function pickHigherVersion(a: string | null, b: string | null): string | null;
 export declare function fetchLatestVersionFromRegistry(registryUrl?: string, fetchTimeoutMs?: number): Promise<string | null>;
 /**
  * Detects whether the currently-running gsd binary was installed via `bun add -g`.
@@ -29,18 +41,20 @@ export declare function resolveInstallCommand(pkg: string, options?: {
     env?: NodeJS.ProcessEnv;
 }): string;
 export interface UpdateCheckOptions {
+    packageName?: string;
     currentVersion?: string;
     cachePath?: string;
     registryUrl?: string;
     checkIntervalMs?: number;
     fetchTimeoutMs?: number;
-    onUpdate?: (current: string, latest: string) => void;
+    onUpdate?: (current: string, latest: string, packageName: string) => void;
 }
 /**
  * Non-blocking update check. Queries npm registry at most once per 24h,
  * caches the result, and prints a banner if a newer version is available.
  */
 export declare function checkForUpdates(options?: UpdateCheckOptions): Promise<void>;
+export declare function checkForGsdBrowserUpdates(options?: UpdateCheckOptions): Promise<void>;
 /**
  * Interactive update prompt shown at startup when a newer version is available.
  * Fetches the latest version (with cache), then asks the user whether to