@opengsd/gsd-pi 1.1.1-dev.2034b16 → 1.1.1-dev.2de7ea0

package/dist/resources/extensions/browser-tools/package.json

@@ -4,7 +4,7 @@
   "version": "1.0.0",
   "type": "module",
   "scripts": {
-    "test": "node --test tests/*.test.mjs"
+    "test": "node --import ../gsd/tests/resolve-ts.mjs --experimental-strip-types --test tests/*.test.mjs"
   },
   "pi": {
     "extensions": [
@@ -12,10 +12,14 @@
     ]
   },
   "peerDependencies": {
+    "@opengsd/gsd-browser": ">=0.1.27",
     "playwright": ">=1.40.0",
     "sharp": ">=0.33.0"
   },
   "peerDependenciesMeta": {
+    "@opengsd/gsd-browser": {
+      "optional": true
+    },
     "playwright": {
       "optional": true
     },

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -32,7 +32,7 @@ import { isDbAvailable, getDbPath, refreshOpenDatabaseFromDisk, getTask, getSlic
 import { renderPlanCheckboxes, renderRoadmapFromDb } from "./markdown-renderer.js";
 import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { consumeSignal } from "./session-status-io.js";
-import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
+import { checkPostUnitHooks, consumeHookFailure, isRetryPending, consumeRetryTrigger, consumeGateBlock, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
@@ -1860,18 +1860,25 @@ export async function postUnitPostVerification(pctx) {
     // ── Post-unit hooks ──
     if (s.currentUnit && !s.stepMode) {
         const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
+        persistHookState(s.basePath);
         if (hookUnit) {
             if (s.currentUnit) {
                 await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
             }
-            persistHookState(s.basePath);
             return enqueueSidecar(s, ctx, { kind: "hook", unitType: hookUnit.unitType, unitId: hookUnit.unitId, prompt: hookUnit.prompt, model: hookUnit.model }, { hookName: hookUnit.hookName });
         }
+        const hookFailure = consumeHookFailure();
+        if (hookFailure) {
+            ctx.ui.notify(`Post-unit hook ${hookFailure.hookName} failed for ${hookFailure.unitId}: ${hookFailure.reason}. Pausing auto-mode.`, "warning");
+            await pauseAuto(ctx, pi);
+            return "stopped";
+        }
         // Check if a hook requested a retry of the trigger unit
         if (isRetryPending()) {
             const trigger = consumeRetryTrigger();
             if (trigger) {
-                ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`, "info");
+                persistHookState(s.basePath);
+                ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting trigger unit state.`, "info");
                 await s.orchestration?.retryActiveUnit({
                     unitType: trigger.unitType,
                     unitId: trigger.unitId,
@@ -1918,6 +1925,17 @@ export async function postUnitPostVerification(pctx) {
                 // Fall through to normal dispatch — deriveState will re-derive the unit
             }
         }
+        const gateBlock = consumeGateBlock();
+        if (gateBlock) {
+            persistHookState(s.basePath);
+            const verdict = gateBlock.verdict ? ` verdict=${gateBlock.verdict};` : "";
+            const artifact = gateBlock.artifact ? ` artifact=${gateBlock.artifact};` : "";
+            const message = `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId}:` +
+                `${verdict}${artifact} ${gateBlock.reason}. Run /gsd status to inspect, then /gsd auto after recovery.`;
+            ctx.ui.notify(message, "warning");
+            await pauseAuto(ctx, pi);
+            return "stopped";
+        }
     }
     // ── Fast-path stop detection (#3487) ──
     // Before waiting for triage, check if any PENDING captures contain explicit

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -1271,7 +1271,7 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                     if (hasVerdict(uatContent))
                         continue;
                     // Also check the ASSESSMENT file — the run-uat prompt writes the verdict
-                    // there (via gsd_summary_save artifact_type:"ASSESSMENT"), not into the
+                    // there (via gsd_uat_result_save), not into the
                     // UAT spec file. Without this check the unit re-dispatches indefinitely.
                     const assessmentFile = resolveSliceFile(base, mid, sid, "ASSESSMENT");
                     if (assessmentFile) {
@@ -2568,17 +2568,26 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         if (isDbAvailable()) {
             const milestone = getMilestone(mid);
             if (milestone) {
+                const escapeCell = (value) => value.replace(/[\\|]/g, (char) => `\\${char}`).replace(/\r?\n/g, " ");
                 const classes = [];
                 if (milestone.verification_contract)
-                    classes.push(`- **Contract:** ${milestone.verification_contract}`);
+                    classes.push(`| Contract | ${escapeCell(milestone.verification_contract)} |`);
                 if (milestone.verification_integration)
-                    classes.push(`- **Integration:** ${milestone.verification_integration}`);
+                    classes.push(`| Integration | ${escapeCell(milestone.verification_integration)} |`);
                 if (milestone.verification_operational)
-                    classes.push(`- **Operational:** ${milestone.verification_operational}`);
+                    classes.push(`| Operational | ${escapeCell(milestone.verification_operational)} |`);
                 if (milestone.verification_uat)
-                    classes.push(`- **UAT:** ${milestone.verification_uat}`);
+                    classes.push(`| UAT | ${escapeCell(milestone.verification_uat)} |`);
                 if (classes.length > 0) {
-                    const verificationClasses = `### Verification Classes (from planning)\n\nThese verification tiers were defined during milestone planning. Each non-empty class must be checked for evidence during validation.\n\n${classes.join("\n")}`;
+                    const verificationClasses = [
+                        "### Verification Classes (from planning)",
+                        "",
+                        "These verification tiers were defined during milestone planning. Every row in this table must appear in `verificationClasses` with the same canonical class name.",
+                        "",
+                        "| Class | Planned Check |",
+                        "| --- | --- |",
+                        ...classes,
+                    ].join("\n");
                     inlined.push(verificationClasses);
                     trackPromptContext(contextTelemetry, "verification-classes", "inline", verificationClasses);
                 }

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -1010,7 +1010,7 @@ export function registerDbTools(pi) {
         promptGuidelines: [
             "Use gsd_validate_milestone when all slices are done and the milestone needs validation before completion.",
             "Parameters: milestoneId, verdict, remediationRound, successCriteriaChecklist, sliceDeliveryAudit, crossSliceIntegration, requirementCoverage, verificationClasses (optional), verdictRationale, remediationPlan (optional).",
-            "If verification classes were planned, verificationClasses must include canonical class rows using the exact class names Contract, Integration, Operational, and UAT when present in planning.",
+            "If verification classes were planned, verificationClasses must be a complete canonical table with one row for every applicable planned class using the exact class names Contract, Integration, Operational, and UAT. Do not submit a partial table.",
             "Planned verification text marked as none/not required/not applicable/N/A (including suffixed variants such as 'not required - backend-only') is treated as not applicable and does not require a class row.",
             "If verdict is 'needs-remediation', also provide remediationPlan and use gsd_reassess_roadmap to add remediation slices to the roadmap.",
             "On success, returns validationPath where VALIDATION.md was written.",
@@ -1023,7 +1023,7 @@ export function registerDbTools(pi) {
             sliceDeliveryAudit: Type.String({ description: "Markdown table auditing each slice's claimed vs delivered output" }),
             crossSliceIntegration: Type.String({ description: "Markdown describing any cross-slice boundary mismatches" }),
             requirementCoverage: Type.String({ description: "Markdown describing any unaddressed requirements" }),
-            verificationClasses: Type.Optional(Type.String({ description: "Markdown describing verification class compliance and gaps using canonical class names (Contract, Integration, Operational, UAT) for each applicable planned class" })),
+            verificationClasses: Type.Optional(Type.String({ description: "Complete markdown table describing verification class compliance and gaps; include one canonical row for every applicable planned class (Contract, Integration, Operational, UAT)" })),
             verdictRationale: Type.String({ description: "Why this verdict was chosen" }),
             remediationPlan: Type.Optional(Type.String({ description: "Remediation plan (required if verdict is needs-remediation)" })),
         }),

package/dist/resources/extensions/gsd/browser-evidence.js

@@ -1,17 +1,44 @@
 // Project/App: gsd-pi
 // File Purpose: Shared browser-observable UAT requirement and evidence detection.
-export const BROWSER_REQUIREMENT_RE = /\b(?:browser|file:\/\/|localhost|dom|localstorage|click(?:ing|ed)?|button|screenshot|snapshot|reload(?:ed)?|page refresh|user-visible|strikethrough|search box)\b/i;
+export const BROWSER_REQUIREMENT_RE = /\b(?:file:\/\/|localhost|playwright|chrome|screenshot|snapshot|browser_(?:assert|batch|find|verify|snapshot_refs))\b|\b(?:open|launch|navigate|load|visit|serve|start)\b.{0,80}\b(?:browser|page|localhost|file:\/\/)\b|\bbrowser\s+(?:check|session|test|uat|tool|automation|interaction|flow)\b/i;
 export const NO_BROWSER_EVIDENCE_RE = /\b(?:no|without|not|wasn'?t|isn'?t)\s+(?:automated\s+)?(?:live\s+)?browser(?:\s+(?:session|test|uat))?|\bno\s+automated\s+browser\b|\bnot\s+conducted\b/i;
 export const BROWSER_RUNTIME_RE = /\b(?:browser|playwright|chrome|camoufox|browser_(?:assert|batch|find|verify|snapshot_refs)|screenshot|snapshot|file:\/\/|localhost)\b/i;
 export const BROWSER_ACTION_RE = /\b(?:open(?:ed)?|navigate(?:d)?|click(?:ed)?|type(?:d)?|reload(?:ed)?|capture(?:d)?|screenshot|snapshot)\b/i;
 export const BROWSER_ASSERTION_RE = /\b(?:assert(?:ed|ion)?|observed|confirmed|verified|expected|visible|text|count|label|strikethrough|localstorage|screenshot|snapshot|passed)\b/i;
+const NON_REQUIREMENT_BROWSER_HEADING_RE = /^(?:not\s+proven|not\s+covered|out\s+of\s+scope|deferred|follow-?ups?|known\s+limitations|notes\s+for\s+tester)\b/i;
+const NON_REQUIREMENT_BROWSER_LINE_RE = /\b(?:deferred|not\s+proven|not\s+covered|out\s+of\s+scope|future\s+slice|follow-?up|no\s+(?:live\s+)?browser|without\s+(?:a\s+)?browser|not\s+(?:a\s+)?browser)\b/i;
 export function compactTextParts(parts) {
     return parts.flatMap((part) => Array.isArray(part) ? part : [part])
         .filter((part) => typeof part === "string" && part.trim().length > 0)
         .join("\n");
 }
 export function hasBrowserRequiredText(text) {
-    return BROWSER_REQUIREMENT_RE.test(text);
+    let inNonRequirementSection = false;
+    let nonRequirementDepth = 0;
+    for (const line of text.split(/\r?\n/)) {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+        if (headingMatch) {
+            const depth = headingMatch[1].length;
+            const title = headingMatch[2] ?? "";
+            // Only update section context when at the same or higher level than the
+            // heading that opened the non-requirement zone. A sub-heading deeper than
+            // the opening heading must not escape or re-enter the zone on its own.
+            if (!inNonRequirementSection || depth <= nonRequirementDepth) {
+                inNonRequirementSection = NON_REQUIREMENT_BROWSER_HEADING_RE.test(title);
+                nonRequirementDepth = inNonRequirementSection ? depth : 0;
+            }
+            // Check the heading title itself — section state is already updated, so
+            // we correctly skip headings that opened a non-requirement zone.
+            if (!inNonRequirementSection && BROWSER_REQUIREMENT_RE.test(title))
+                return true;
+            continue;
+        }
+        if (inNonRequirementSection || NON_REQUIREMENT_BROWSER_LINE_RE.test(line))
+            continue;
+        if (BROWSER_REQUIREMENT_RE.test(line))
+            return true;
+    }
+    return false;
 }
 export function hasBrowserEvidenceText(text) {
     if (!text.trim())

package/dist/resources/extensions/gsd/commands/handlers/ops.js

@@ -266,8 +266,8 @@ Examples:
         await handleInspect(ctx);
         return true;
     }
-    if (trimmed === "update" || trimmed === "upgrade") {
-        await handleUpdate(ctx);
+    if (trimmed === "update" || trimmed.startsWith("update ") || trimmed === "upgrade" || trimmed.startsWith("upgrade ")) {
+        await handleUpdate(ctx, trimmed.replace(/^(?:update|upgrade)\s*/, "").trim());
         return true;
     }
     if (trimmed === "fast" || trimmed.startsWith("fast ")) {

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -5,6 +5,8 @@
  * handleRunHook, handleUpdate, handleSkillHealth
  */
 import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
 import { join, resolve as resolvePath, sep } from "node:path";
 import { homedir } from "node:os";
 import { deriveState } from "./state.js";
@@ -20,7 +22,10 @@ import { loadPrompt } from "./prompt-loader.js";
 import { isPnpmInstall } from "../../shared/package-manager-detection.js";
 import { buildDoctorHealIssuePayload, buildDoctorHealSummary, buildWorkflowDispatchContent, } from "./workflow-protocol.js";
 import { restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch, } from "./bootstrap/register-hooks.js";
+const GSD_PI_PACKAGE = "@opengsd/gsd-pi";
+const GSD_BROWSER_PACKAGE = "@opengsd/gsd-browser";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
+const BROWSER_UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-browser/latest";
 const UPDATE_FETCH_TIMEOUT_MS = 5000;
 // Detects a bun-installed gsd via `process.argv[1]`. Mirrors isBunInstall in
 // src/update-check.ts — duplicated because tsconfig.resources.json rootDir
@@ -47,11 +52,11 @@ function resolveInstallCommand(pkg) {
         return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
-async function fetchLatestVersionForCommand() {
+async function fetchLatestVersionForCommand(registryUrl = UPDATE_REGISTRY_URL) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), UPDATE_FETCH_TIMEOUT_MS);
     try {
-        const res = await fetch(UPDATE_REGISTRY_URL, { signal: controller.signal });
+        const res = await fetch(registryUrl, { signal: controller.signal });
         if (!res.ok)
             return null;
         const data = (await res.json());
@@ -65,6 +70,19 @@ async function fetchLatestVersionForCommand() {
         clearTimeout(timeout);
     }
 }
+function resolveInstalledPackageVersionForCommand(packageName) {
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return typeof pkg.version === "string" && pkg.version.trim().length > 0
+            ? pkg.version.trim().replace(/^v/, "")
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
@@ -386,27 +404,74 @@ function compareSemverLocal(a, b) {
     }
     return 0;
 }
-export async function handleUpdate(ctx) {
+function formatCommandVersion(version) {
+    return version ? `v${version}` : "unknown";
+}
+function pickHigherVersionForCommand(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return compareSemverLocal(a, b) >= 0 ? a : b;
+}
+// Mirrors resolveGsdBrowserPathVersion in src/update-check.ts — duplicated because
+// tsconfig.resources.json rootDir prevents importing from src/.
+function resolveGsdBrowserPathVersionForCommand(env = process.env) {
+    const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
+    if (explicit)
+        return explicit.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    try {
+        const out = execFileSync("gsd-browser", ["--version"], {
+            encoding: "utf-8",
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        });
+        return out.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleUpdate(ctx, args = "") {
     const { execSync } = await import("node:child_process");
-    const NPM_PACKAGE = "@opengsd/gsd-pi";
-    const current = process.env.GSD_VERSION || "0.0.0";
-    ctx.ui.notify(`Current version: v${current}\nChecking npm registry...`, "info");
-    const latest = await fetchLatestVersionForCommand();
+    const target = args.trim();
+    const browserUpdate = target === "browser" || target === "gsd-browser";
+    if (target && !browserUpdate) {
+        ctx.ui.notify("Usage: /gsd update [browser]", "warning");
+        return;
+    }
+    const NPM_PACKAGE = browserUpdate ? GSD_BROWSER_PACKAGE : GSD_PI_PACKAGE;
+    const registryUrl = browserUpdate ? BROWSER_UPDATE_REGISTRY_URL : UPDATE_REGISTRY_URL;
+    const bundledVersion = browserUpdate
+        ? resolveInstalledPackageVersionForCommand(GSD_BROWSER_PACKAGE)
+        : null;
+    const current = browserUpdate
+        ? pickHigherVersionForCommand(bundledVersion, resolveGsdBrowserPathVersionForCommand())
+        : process.env.GSD_VERSION || "0.0.0";
+    const label = browserUpdate ? "gsd-browser version" : "version";
+    ctx.ui.notify(`Current ${label}: ${formatCommandVersion(current)}\nChecking npm registry...`, "info");
+    const latest = await fetchLatestVersionForCommand(registryUrl);
     if (!latest) {
         ctx.ui.notify("Failed to reach npm registry. Check your network connection.", "error");
         return;
     }
-    if (compareSemverLocal(latest, current) <= 0) {
-        ctx.ui.notify(`Already up to date (v${current}).`, "info");
+    if (current && compareSemverLocal(latest, current) <= 0) {
+        ctx.ui.notify(`Already up to date (${formatCommandVersion(current)}).`, "info");
         return;
     }
-    ctx.ui.notify(`Updating: v${current} → v${latest}...`, "info");
+    ctx.ui.notify(`Updating: ${formatCommandVersion(current)} → v${latest}...`, "info");
     const installCmd = resolveInstallCommand(`${NPM_PACKAGE}@latest`);
     try {
         execSync(installCmd, {
             stdio: ["ignore", "pipe", "ignore"],
         });
-        ctx.ui.notify(`Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
+        const newPathVersion = browserUpdate ? resolveGsdBrowserPathVersionForCommand() : null;
+        const pathReady = !browserUpdate || (!!newPathVersion && compareSemverLocal(newPathVersion, latest) >= 0);
+        ctx.ui.notify(browserUpdate
+            ? `Updated gsd-browser to v${latest}. Restart your GSD session to use the new browser automation version.` +
+                (pathReady ? "" : "\nNote: Ensure the npm global bin directory is on your PATH so MCP automation uses the updated binary.")
+            : `Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
     }
     catch {
         ctx.ui.notify(`Update failed. Try manually: ${installCmd}`, "error");

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -33,7 +33,8 @@ export function formatMcpInitResult(status, configPath, targetPath) {
         `Project: ${targetPath}`,
         `Config:   ${configPath}`,
         "",
-        "MCP-capable clients can now load the GSD workflow MCP server from this folder.",
+        "MCP-capable clients can now load the GSD workflow and gsd-browser MCP servers from this folder.",
+        "Pi Providers use the managed gsd-browser engine directly; this project config is for External MCP Clients.",
         "Restart or reconnect any client that already has this project open.",
     ].join("\n");
 }

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -305,10 +305,18 @@ This config sets a parent workspace with two child repositories. The implicit `p
   - `max_cycles`: number — max times this hook fires per trigger (default: 1, max: 10).
   - `model`: string — optional model override.
   - `artifact`: string — expected output file name (relative to task/slice dir). Hook is skipped if file already exists (idempotent).
+  - `criticality`: `"advisory"` or `"blocking"` — advisory preserves current best-effort behavior; blocking requires clean hook completion plus a valid outcome verdict before auto-mode advances. Default: `"advisory"`.
   - `retry_on`: string — if this file is produced instead of the artifact, re-run the trigger unit then re-run hooks.
+  - `on_block`: object — optional routing for blocking findings:
+    - `action`: `"retry-unit"`, `"retry-task"`, `"queue-task"`, `"queue-slice"`, or `"pause"`.
+    - `artifact`: string — optional compatibility artifact for retry routing.
   - `agent`: string — agent definition file to use for hook execution.
   - `enabled`: boolean — toggle without removing (default: `true`).
 
+  Blocking hook artifacts must begin with YAML frontmatter containing either `verdict` or `outcome.verdict`.
+  Supported verdicts are `pass`, `advisory`, `needs-rework`, `needs-remediation`, and `needs-attention`.
+  `pass` and `advisory` continue; `needs-rework` retries the trigger unit when routed with `retry-unit`/`retry-task`; `needs-remediation` and `needs-attention` pause with recovery guidance.
+
 - `pre_dispatch_hooks`: array — hooks that fire before a unit is dispatched. Each entry has:
   - `name`: string — unique hook identifier.
   - `before`: string[] — unit types to intercept.

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -258,14 +258,14 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 catch {
                     count = MAX_UAT_ATTEMPTS + 1;
                 }
-                if (count <= MAX_UAT_ATTEMPTS)
+                if (count < MAX_UAT_ATTEMPTS)
                     continue;
                 issues.push({
                     severity: "warning",
                     code: "uat_retry_exhausted",
                     scope: "slice",
                     unitId: `${mid}/${sid}`,
-                    message: `run-uat for ${mid}/${sid} exhausted ${count - 1} retry attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
+                    message: `run-uat for ${mid}/${sid} exhausted ${count} attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
                     file: `.gsd/runtime/${fileName}`,
                     fixable: true,
                 });

package/dist/resources/extensions/gsd/mcp-project-config.js

@@ -1,12 +1,11 @@
-import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { basename, resolve } from "node:path";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { GSD_BROWSER_MCP_SERVER_NAME, resolveBundledGsdBrowserCliPath, resolveGsdBrowserMcpLaunchConfig, } from "../shared/gsd-browser-cli.js";
 import { assertSafeDirectory } from "./validate-directory.js";
 import { detectWorkflowMcpLaunchConfig } from "./workflow-mcp.js";
 export const GSD_WORKFLOW_MCP_SERVER_NAME = "gsd-workflow";
-export const GSD_BROWSER_MCP_SERVER_NAME = "gsd-browser";
+export { GSD_BROWSER_MCP_SERVER_NAME, resolveBundledGsdBrowserCliPath };
 export function resolveBundledGsdCliPath(env = process.env) {
     const explicit = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
     if (explicit)
@@ -22,30 +21,6 @@ export function resolveBundledGsdCliPath(env = process.env) {
     }
     return null;
 }
-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 buildProjectWorkflowMcpServerConfig(projectRoot, env = process.env) {
     return buildProjectWorkflowMcpServerSpec(projectRoot, env).server;
 }
@@ -69,68 +44,26 @@ function buildProjectWorkflowMcpServerSpec(projectRoot, env = process.env) {
         },
     };
 }
-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 isEnvDisabled(value) {
     if (!value)
         return false;
     const normalized = value.trim().toLowerCase();
     return normalized === "0" || normalized === "false" || normalized === "off";
 }
-function buildBrowserSessionName(projectRoot) {
-    const resolvedProjectRoot = resolve(projectRoot);
-    const base = basename(resolvedProjectRoot)
-        .replace(/[^a-zA-Z0-9._-]+/g, "-")
-        .replace(/^-+|-+$/g, "") || "project";
-    const hash = createHash("sha1").update(resolvedProjectRoot).digest("hex").slice(0, 8);
-    return `gsd-${base}-${hash}`;
-}
 export function buildProjectBrowserMcpServerConfig(projectRoot, env = process.env) {
     return buildProjectBrowserMcpServerSpec(projectRoot, env)?.server ?? null;
 }
 function buildProjectBrowserMcpServerSpec(projectRoot, env = process.env) {
     if (isEnvDisabled(env.GSD_BROWSER_MCP_ENABLED))
         return null;
-    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 bundledCliPath = !explicitCommand && !explicitCliPath ? resolveBundledGsdBrowserCliPath(env) : null;
-    const command = explicitCommand
-        || explicitCliPath
-        || (bundledCliPath ? process.execPath : undefined)
-        || "gsd-browser";
-    const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
-        ? explicitArgs.map(String)
-        : [
-            ...(bundledCliPath ? [bundledCliPath] : []),
-            "mcp",
-            "--session",
-            buildBrowserSessionName(resolvedProjectRoot),
-            "--identity-scope",
-            "project",
-            "--identity-project",
-            resolvedProjectRoot,
-        ];
-    const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
+    const launch = resolveGsdBrowserMcpLaunchConfig(projectRoot, env);
     return {
-        serverName,
+        serverName: launch.serverName,
         server: {
-            command,
-            args,
-            cwd,
-            ...(explicitEnv ? { env: explicitEnv } : {}),
+            command: launch.command,
+            args: launch.args,
+            cwd: launch.cwd,
+            ...(launch.env ? { env: launch.env } : {}),
         },
     };
 }

package/dist/resources/extensions/gsd/post-unit-hooks.js

@@ -19,6 +19,15 @@ export function isRetryPending() {
 export function consumeRetryTrigger() {
     return getOrCreateRegistry().consumeRetryTrigger();
 }
+export function consumeHookFailure() {
+    return getOrCreateRegistry().consumeHookFailure();
+}
+export function isGateBlockPending() {
+    return getOrCreateRegistry().isGateBlockPending();
+}
+export function consumeGateBlock() {
+    return getOrCreateRegistry().consumeGateBlock();
+}
 export function resetHookState() {
     getOrCreateRegistry().resetState();
 }

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -15,6 +15,14 @@ const VALID_UOK_TURN_ACTIONS = new Set([
     "snapshot",
     "status-only",
 ]);
+const VALID_POST_UNIT_HOOK_CRITICALITIES = new Set(["advisory", "blocking"]);
+const VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS = new Set([
+    "retry-unit",
+    "retry-task",
+    "queue-task",
+    "queue-slice",
+    "pause",
+]);
 export function validatePreferences(preferences) {
     const errors = [];
     const warnings = [];
@@ -474,9 +482,40 @@ export function validatePreferences(preferences) {
             if (typeof hook.artifact === "string" && hook.artifact.trim()) {
                 validHook.artifact = hook.artifact.trim();
             }
+            if (hook.criticality !== undefined) {
+                const criticality = typeof hook.criticality === "string" ? hook.criticality.trim() : "";
+                if (VALID_POST_UNIT_HOOK_CRITICALITIES.has(criticality)) {
+                    validHook.criticality = criticality;
+                }
+                else {
+                    errors.push(`post_unit_hooks "${name}" invalid criticality: ${String(hook.criticality)}`);
+                }
+            }
             if (typeof hook.retry_on === "string" && hook.retry_on.trim()) {
                 validHook.retry_on = hook.retry_on.trim();
             }
+            if (hook.on_block !== undefined) {
+                if (!hook.on_block || typeof hook.on_block !== "object") {
+                    errors.push(`post_unit_hooks "${name}" on_block must be an object`);
+                }
+                else {
+                    const onBlock = hook.on_block;
+                    const action = typeof onBlock.action === "string" ? onBlock.action.trim() : "";
+                    if (!VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS.has(action)) {
+                        errors.push(`post_unit_hooks "${name}" invalid on_block action: ${String(onBlock.action)}`);
+                    }
+                    else {
+                        validHook.on_block = { action: action };
+                        if (typeof onBlock.artifact === "string" && onBlock.artifact.trim()) {
+                            validHook.on_block.artifact = onBlock.artifact.trim();
+                        }
+                    }
+                }
+            }
+            if (validHook.criticality === "blocking" && !validHook.artifact) {
+                errors.push(`post_unit_hooks "${name}" criticality blocking requires artifact`);
+                continue;
+            }
             if (typeof hook.agent === "string" && hook.agent.trim()) {
                 validHook.agent = hook.agent.trim();
             }

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -26,9 +26,16 @@ function hasRequiredExtensionAssets(rootDir, exists = existsSync) {
     return (exists(join(rootDir, "prompts")) &&
         exists(join(rootDir, "templates", "task-summary.md")));
 }
+function isSourceExtensionDir(moduleDir) {
+    return moduleDir.replaceAll("\\", "/").endsWith("/src/resources/extensions/gsd");
+}
 export function resolveExtensionDirFromCandidates(moduleDir, agentGsdDir, exists = existsSync) {
     const moduleUsable = hasRequiredExtensionAssets(moduleDir, exists);
     const agentUsable = hasRequiredExtensionAssets(agentGsdDir, exists);
+    // Source checkouts must use their own prompt tree. Otherwise local tests and
+    // dev runs can silently render stale prompts from ~/.gsd/agent/extensions/gsd.
+    if (moduleUsable && isSourceExtensionDir(moduleDir))
+        return moduleDir;
     // Prefer the user-local extension tree when both are valid. This avoids
     // leaking npm/global-install paths into prompts on Windows.
     if (agentUsable)