@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.595401e

package/dist/resources/extensions/gsd/state-reconciliation/drift/roadmap.js

@@ -4,7 +4,7 @@
 // checkboxes) and the DB slice rows for that milestone, then re-renders the
 // ROADMAP projection from the authoritative DB rows.
 import { existsSync, readFileSync } from "node:fs";
-import { getMilestone, getMilestoneSlices, isDbAvailable, } from "../../gsd-db.js";
+import { getMilestone, getMilestoneSlices, getSliceTasks, isDbAvailable, } from "../../gsd-db.js";
 import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
@@ -18,6 +18,15 @@ function arraysEqual(a, b) {
             return false;
     return true;
 }
+function getSlicesReadyForDivergenceCheck(milestoneId, dbSlices) {
+    const ready = new Set();
+    for (const slice of dbSlices) {
+        if (isClosedStatus(slice.status) || getSliceTasks(milestoneId, slice.id).length > 0) {
+            ready.add(slice.id);
+        }
+    }
+    return ready;
+}
 function milestoneHasDivergence(basePath, milestoneId) {
     const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
     if (!roadmapPath || !existsSync(roadmapPath))
@@ -31,6 +40,10 @@ function milestoneHasDivergence(basePath, milestoneId) {
     }
     const dbSlices = getMilestoneSlices(milestoneId);
     const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+    const readySliceIds = getSlicesReadyForDivergenceCheck(milestoneId, dbSlices);
+    if (dbSlices.length > 0 && readySliceIds.size === 0) {
+        return false;
+    }
     const roadmapSliceIds = new Set();
     for (let i = 0; i < roadmap.slices.length; i++) {
         const roadmapSlice = roadmap.slices[i];
@@ -39,6 +52,8 @@ function milestoneHasDivergence(basePath, milestoneId) {
         const dbSlice = dbSliceMap.get(roadmapSlice.id);
         if (!dbSlice)
             return true; // Roadmap has a slice the DB doesn't.
+        if (!readySliceIds.has(dbSlice.id))
+            continue;
         if (dbSlice.sequence !== expectedSequence)
             return true;
         if (!arraysEqual(dbSlice.depends, roadmapSlice.depends))
@@ -47,6 +62,8 @@ function milestoneHasDivergence(basePath, milestoneId) {
             return true;
     }
     for (const dbSlice of dbSlices) {
+        if (!readySliceIds.has(dbSlice.id))
+            continue;
         if (!roadmapSliceIds.has(dbSlice.id))
             return true;
     }

package/dist/resources/extensions/gsd/state-reconciliation/index.js

@@ -2,6 +2,7 @@
 // File Purpose: ADR-017 drift-driven State Reconciliation Module entry point.
 // reconcileBeforeDispatch runs before every Dispatch decision and worker spawn.
 import { deriveState as defaultDeriveState, invalidateStateCache as defaultInvalidate, } from "../state.js";
+import { clearParseCache as defaultClearParseCache } from "../files.js";
 import { ReconciliationFailedError, } from "./errors.js";
 import { DRIFT_REGISTRY } from "./registry.js";
 export { ReconciliationFailedError } from "./errors.js";
@@ -10,6 +11,7 @@ const MAX_PASSES = 2;
 const defaultDeps = {
     invalidateStateCache: defaultInvalidate,
     deriveState: defaultDeriveState,
+    clearParseCache: defaultClearParseCache,
 };
 /**
  * Drift-driven pre-dispatch reconciliation per ADR-017.
@@ -27,6 +29,7 @@ const defaultDeps = {
  */
 export async function reconcileBeforeDispatch(basePath, deps = defaultDeps) {
     const registry = deps.registry ?? DRIFT_REGISTRY;
+    const clearParseCache = deps.clearParseCache ?? defaultClearParseCache;
     const repaired = [];
     for (let pass = 0; pass < MAX_PASSES; pass++) {
         deps.invalidateStateCache();
@@ -67,6 +70,9 @@ export async function reconcileBeforeDispatch(basePath, deps = defaultDeps) {
                 failures.push({ drift: record, cause });
             }
         }
+        if (repairedThisPass) {
+            clearParseCache();
+        }
         if (blockers.length > 0) {
             let blockerState = stateSnapshot;
             if (repairedThisPass) {

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

@@ -35,7 +35,7 @@ function formatNeedsRemediationBlocker(milestoneId) {
     return [
         `Milestone ${milestoneId} is blocked because milestone validation returned needs-remediation, but all slices are complete.`,
         `Fix options:`,
-        `1. Add remediation slices with \`gsd_reassess_roadmap\`, then run \`/gsd auto\``,
+        `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");
@@ -724,8 +724,8 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
         }
     }
     // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
-    // next task. `awaiting_review` tasks (continueWithDefault=true) are NOT
-    // surfaced here — they let the loop continue.
+    // next task. `awaiting_review` tasks (continueWithDefault=true) still pause
+    // here so silence is never treated as consent.
     //
     // We do NOT gate this on `phases.mid_execution_escalation` — creation of
     // new escalations is gated at the write site (tools/complete-task.ts:315),

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

@@ -132,14 +132,16 @@
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
   - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`
+  - For absence checks, use `! grep -q "pattern" file` or `! rg -q "pattern" file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches
   - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
   - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
+  - BAD: `grep -c "old_api" src/index.ts`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
   - GOOD: `python3 -m pytest tests/ -q --tb=short`
-  - GOOD: `node --test tests/verify-doc.test.js`, `grep -q "Required heading" doc.md`, `test -s doc.md`
+  - GOOD: `node --test tests/verify-doc.test.js`, `grep -q "Required heading" doc.md`, `! grep -q "old_api" src/index.ts`, `test -s doc.md`
 
   Integration closure rule:
   - At least one slice in any multi-boundary milestone should perform real composition/wiring, not just contract hardening

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -314,9 +314,18 @@ export async function handleCompleteTask(params, basePath) {
     // overwrite it; gate rows are UPSERT-keyed per task and will also be
     // overwritten. This restores the invariant that deriveState() sees a
     // consistent "task not done" view so the loop re-dispatches the task.
+    let escalationMetadata;
     if (validatedEscalationArtifact) {
         try {
-            writeEscalationArtifact(artifactBasePath, validatedEscalationArtifact);
+            const escalationPath = writeEscalationArtifact(artifactBasePath, validatedEscalationArtifact);
+            escalationMetadata = {
+                artifactPath: escalationPath,
+                question: validatedEscalationArtifact.question,
+                options: validatedEscalationArtifact.options,
+                recommendation: validatedEscalationArtifact.recommendation,
+                recommendationRationale: validatedEscalationArtifact.recommendationRationale,
+                continueWithDefault: validatedEscalationArtifact.continueWithDefault,
+            };
         }
         catch (escalationErr) {
             const msg = `complete-task escalation write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${escalationErr.message}`;
@@ -378,6 +387,7 @@ export async function handleCompleteTask(params, basePath) {
         sliceId: params.sliceId,
         milestoneId: params.milestoneId,
         summaryPath,
+        ...(escalationMetadata ? { escalation: escalationMetadata } : {}),
         ...(projectionStale ? { stale: true } : {}),
     };
 }

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -5,6 +5,27 @@ import { realpathSync } from "node:fs";
 import path from "node:path";
 import { isContextModeEnabled } from "../preferences-types.js";
 import { contextModeDisabledResult } from "./context-mode-tool-result.js";
+const UAT_EXEC_INTENTS = [
+    "uat-artifact-check",
+    "uat-runtime-check",
+    "uat-browser-check",
+    "uat-service-start",
+    "uat-log-inspection",
+];
+const UAT_EXEC_INTENT_ALIASES = {
+    artifact: "uat-artifact-check",
+    "artifact-driven": "uat-artifact-check",
+    runtime: "uat-runtime-check",
+    "runtime-executable": "uat-runtime-check",
+    "live-runtime": "uat-runtime-check",
+    browser: "uat-browser-check",
+    "browser-executable": "uat-browser-check",
+    service: "uat-service-start",
+    "service-start": "uat-service-start",
+    log: "uat-log-inspection",
+    logs: "uat-log-inspection",
+    "log-inspection": "uat-log-inspection",
+};
 export function buildExecOptions(baseDir, cfg, extras) {
     const allowlist = Array.isArray(cfg?.exec_env_allowlist) ? cfg.exec_env_allowlist : EXEC_DEFAULTS.envAllowlist;
     const stdoutCap = clampNumber(cfg?.exec_stdout_cap_bytes, EXEC_DEFAULTS.stdoutCapBytes, 4_096, 16_777_216);
@@ -73,6 +94,39 @@ function normalizeScript(params) {
     }
     return paramError("script is required and must be a non-empty string");
 }
+function normalizeRequiredString(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return paramError(`${field} is required and must be a non-empty string`);
+    }
+    return value.trim();
+}
+function normalizeUatIntent(value) {
+    if (typeof value !== "string") {
+        return paramError(`intent is required and must be one of: ${UAT_EXEC_INTENTS.join(", ")}`);
+    }
+    const normalized = value.trim().toLowerCase();
+    if (UAT_EXEC_INTENTS.includes(normalized))
+        return normalized;
+    const alias = UAT_EXEC_INTENT_ALIASES[normalized];
+    if (alias)
+        return alias;
+    return paramError(`invalid intent "${value}" — must be one of: ${UAT_EXEC_INTENTS.join(", ")}`);
+}
+function rejectUatScript(script) {
+    const patterns = [
+        { re: /\b(?:npm|pnpm|yarn|bun)\s+(?:i|install|add|remove|update|upgrade)\b/i, reason: "package dependency mutation is not allowed during UAT" },
+        { re: /\b(?:pip|pip3|python\s+-m\s+pip)\s+install\b/i, reason: "package dependency mutation is not allowed during UAT" },
+        { re: /\bgit\s+(?:add|commit|push|reset|checkout|switch|merge|rebase|clean|rm|mv|tag|branch)\b/i, reason: "git mutations are not allowed during UAT" },
+        { re: /\brm\s+-[^\n\r;|&]*r[^\n\r;|&]*f\b/i, reason: "destructive filesystem cleanup is not allowed during UAT" },
+        { re: /\b(?:env|printenv)\b(?:\s|$)/i, reason: "dumping environment variables is not allowed during UAT" },
+        { re: /\bcat\s+\.env(?:\b|\.|$)/i, reason: "reading credential files is not allowed during UAT" },
+    ];
+    for (const pattern of patterns) {
+        if (pattern.re.test(script))
+            return pattern.reason;
+    }
+    return null;
+}
 function isToolExecutionResult(value) {
     return typeof value === "object" && value !== null && Array.isArray(value.content);
 }
@@ -207,6 +261,7 @@ export async function executeGsdExec(params, deps) {
             runtime,
             script,
             ...(typeof params.purpose === "string" ? { purpose: params.purpose } : {}),
+            ...(params.metadata && typeof params.metadata === "object" ? { metadata: params.metadata } : {}),
             ...(typeof params.timeout_ms === "number" ? { timeout_ms: params.timeout_ms } : {}),
         }, opts);
         return formatResult(result);
@@ -220,6 +275,60 @@ export async function executeGsdExec(params, deps) {
         };
     }
 }
+export async function executeUatExec(params, deps) {
+    const milestoneId = normalizeRequiredString(params.milestoneId, "milestoneId");
+    if (isToolExecutionResult(milestoneId))
+        return milestoneId;
+    const sliceId = normalizeRequiredString(params.sliceId, "sliceId");
+    if (isToolExecutionResult(sliceId))
+        return sliceId;
+    const checkId = normalizeRequiredString(params.checkId, "checkId");
+    if (isToolExecutionResult(checkId))
+        return checkId;
+    const intent = normalizeUatIntent(params.intent);
+    if (isToolExecutionResult(intent))
+        return intent;
+    const script = normalizeScript(params);
+    if (isToolExecutionResult(script))
+        return script;
+    const rejected = rejectUatScript(script);
+    if (rejected) {
+        return {
+            content: [{ type: "text", text: `Error: gsd_uat_exec blocked command — ${rejected}` }],
+            details: { operation: "gsd_uat_exec", error: "uat_exec_policy_block", reason: rejected },
+            isError: true,
+        };
+    }
+    const result = await executeGsdExec({
+        ...params,
+        script,
+        purpose: typeof params.purpose === "string" && params.purpose.trim().length > 0
+            ? params.purpose
+            : `UAT ${milestoneId}/${sliceId}/${checkId} (${intent})`,
+        metadata: {
+            kind: "uat_exec",
+            milestoneId,
+            sliceId,
+            checkId,
+            intent,
+            ...(typeof params.expected === "string" && params.expected.trim().length > 0
+                ? { expected: params.expected.trim() }
+                : {}),
+        },
+    }, deps);
+    const details = result.details ?? {};
+    return {
+        ...result,
+        details: {
+            ...details,
+            operation: "gsd_uat_exec",
+            milestoneId,
+            sliceId,
+            checkId,
+            intent,
+        },
+    };
+}
 function formatResult(result) {
     const headerLines = [
         `gsd_exec[${result.id}] runtime=${result.runtime} exit=${formatExit(result)} duration=${result.duration_ms}ms`,

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -44,19 +44,12 @@ function getRequiredVerificationClasses(milestoneId) {
         required.push("UAT");
     return required;
 }
-async function collectPersistedBrowserEvidence(basePath, milestoneId) {
-    const chunks = [];
-    for (const slice of getMilestoneSlices(milestoneId)) {
-        const artifactPath = `milestones/${milestoneId}/slices/${slice.id}/${slice.id}-ASSESSMENT.md`;
-        const artifact = getArtifact(artifactPath);
-        if (artifact?.full_content)
-            chunks.push(artifact.full_content);
-        const assessmentPath = resolveSliceFile(basePath, milestoneId, slice.id, "ASSESSMENT");
-        const assessmentContent = assessmentPath ? await loadFile(assessmentPath) : null;
-        if (assessmentContent)
-            chunks.push(assessmentContent);
-    }
-    return chunks.join("\n\n");
+function hasRuntimeExecutableUatEvidenceText(text) {
+    if (!/\buatType:\s*runtime-executable\b/i.test(text))
+        return false;
+    if (!/\bverdict:\s*PASS\b/i.test(text))
+        return false;
+    return /^\|\s*[^|\n]+\s*\|\s*runtime\s*\|\s*PASS\s*\|[^|\n]*\bgsd_uat_exec\b/mi.test(text);
 }
 async function browserEvidenceGateRequiresAttention(params, basePath) {
     if (params.verdict !== "pass")
@@ -77,7 +70,36 @@ async function browserEvidenceGateRequiresAttention(params, basePath) {
     ]);
     if (!hasBrowserRequiredText(requirementText))
         return false;
-    const persistedEvidence = await collectPersistedBrowserEvidence(basePath, params.milestoneId);
+    // Collect per-slice evidence so the runtime bypass is checked independently
+    // for each slice. Concatenating all slices before checking would allow runtime
+    // evidence from one slice to cover another slice's browser requirements.
+    const sliceEvidencePairs = [];
+    for (const slice of slices) {
+        const chunks = [];
+        const artifactPath = `milestones/${params.milestoneId}/slices/${slice.id}/${slice.id}-ASSESSMENT.md`;
+        const artifact = getArtifact(artifactPath);
+        if (artifact?.full_content)
+            chunks.push(artifact.full_content);
+        const assessmentPath = resolveSliceFile(basePath, params.milestoneId, slice.id, "ASSESSMENT");
+        const assessmentContent = assessmentPath ? await loadFile(assessmentPath) : null;
+        if (assessmentContent)
+            chunks.push(assessmentContent);
+        sliceEvidencePairs.push({
+            sliceRequirementText: compactTextParts([slice.demo, slice.goal, slice.success_criteria]),
+            evidenceText: chunks.join("\n\n"),
+        });
+    }
+    const persistedEvidence = sliceEvidencePairs.map((s) => s.evidenceText).join("\n\n");
+    // Runtime bypass: each slice whose own requirement text has browser-observable
+    // criteria must have its own runtime-executable UAT evidence. When no individual
+    // slice has slice-level browser requirements (e.g., they come from milestone-level
+    // fields only), fall back to checking whether any slice has runtime evidence.
+    const browserRequiringSlices = sliceEvidencePairs.filter((s) => hasBrowserRequiredText(s.sliceRequirementText));
+    const runtimeBypasses = browserRequiringSlices.length > 0
+        ? browserRequiringSlices.every((s) => hasRuntimeExecutableUatEvidenceText(s.evidenceText))
+        : sliceEvidencePairs.some((s) => hasRuntimeExecutableUatEvidenceText(s.evidenceText));
+    if (runtimeBypasses)
+        return false;
     const validationEvidence = compactTextParts([
         params.successCriteriaChecklist,
         params.verificationClasses,
@@ -138,12 +160,20 @@ export async function handleValidateMilestone(params, basePath, opts) {
     const requiredClasses = getRequiredVerificationClasses(params.milestoneId);
     if (requiredClasses.length > 0) {
         const verificationClasses = params.verificationClasses ?? "";
-        const missingClass = requiredClasses.find((className) => !new RegExp(`\\b${className}\\b`, "i").test(verificationClasses));
-        if (missingClass) {
+        const missingClasses = requiredClasses.filter((className) => !new RegExp(`\\b${className}\\b`, "i").test(verificationClasses));
+        if (missingClasses.length === 1) {
+            const missingClass = missingClasses[0];
             return {
                 error: `verificationClasses must include canonical row "${missingClass}" because this milestone planned ${missingClass.toLowerCase()} verification`,
             };
         }
+        if (missingClasses.length > 1) {
+            const quotedClasses = missingClasses.map((className) => `"${className}"`).join(", ");
+            const plannedClasses = missingClasses.map((className) => className.toLowerCase()).join(", ");
+            return {
+                error: `verificationClasses must include canonical rows ${quotedClasses} because this milestone planned ${plannedClasses} verification`,
+            };
+        }
     }
     const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
     const shouldApplyBrowserEvidenceGate = !opts?.skipBrowserEvidenceGate &&