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

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -3,6 +3,7 @@ import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkS
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { minimatch } from "minimatch";
 import { GSD_PHASE_SCOPE_DISPLAY_REASON, shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
+import { stripMcpToolPrefix } from "../mcp-tool-name.js";
 import { getIsolationMode } from "../preferences.js";
 import { compileSubagentPermissionContract } from "../unit-context-manifest.js";
 import { logWarning } from "../workflow-logger.js";
@@ -102,10 +103,7 @@ const GATE_SAFE_TOOLS = new Set([
     "ask_user_questions",
 ]);
 export function canonicalToolName(toolName) {
-    if (!toolName.startsWith("mcp__"))
-        return toolName;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    return toolSeparator >= 0 ? toolName.slice(toolSeparator + 2) : toolName;
+    return stripMcpToolPrefix(toolName);
 }
 /**
  * Persistence is ON by default (opt-out).
@@ -385,6 +383,67 @@ export function isDepthConfirmationAnswer(selected, options) {
     // Returning false prevents any free-form string from unlocking the gate.
     return false;
 }
+function findGateQuestion(questions, gateId) {
+    return questions.find((question) => question?.id === gateId);
+}
+function readSelectedGateAnswer(details, questionId) {
+    return details.response?.answers?.[questionId]?.selected;
+}
+function verifyAnsweredGate(basePath, question, fallbackMilestoneId) {
+    const gateId = typeof question.id === "string" ? question.id : "";
+    const milestoneId = extractDepthVerificationMilestoneId(gateId) ?? fallbackMilestoneId ?? null;
+    markApprovalGateVerified(gateId, basePath);
+    markDepthVerified(milestoneId, basePath);
+    clearPendingGate(basePath);
+    return { status: "verified", gateId, milestoneId };
+}
+export function applyAskUserQuestionsGateResult(options) {
+    const { basePath, questions, details, fallbackMilestoneId } = options;
+    const currentPendingGate = getPendingGate(basePath);
+    if (currentPendingGate) {
+        if (details.cancelled || !details.response) {
+            return {
+                status: "waiting",
+                pendingGateId: currentPendingGate,
+                interrupted: details.interrupted === true,
+            };
+        }
+        const pendingQuestion = findGateQuestion(questions, currentPendingGate);
+        if (pendingQuestion) {
+            const selected = readSelectedGateAnswer(details, currentPendingGate);
+            if (isDepthConfirmationAnswer(selected, pendingQuestion.options)) {
+                return verifyAnsweredGate(basePath, pendingQuestion, fallbackMilestoneId);
+            }
+            return { status: "answered", gateId: currentPendingGate };
+        }
+    }
+    if (details.cancelled || !details.response)
+        return { status: "not-gate" };
+    for (const question of questions) {
+        if (typeof question.id !== "string" || !isGateQuestionId(question.id))
+            continue;
+        const selected = readSelectedGateAnswer(details, question.id);
+        if (!isDepthConfirmationAnswer(selected, question.options)) {
+            return { status: "answered", gateId: question.id };
+        }
+        if (currentPendingGate && question.id !== currentPendingGate) {
+            return { status: "answered", gateId: currentPendingGate };
+        }
+        return verifyAnsweredGate(basePath, question, fallbackMilestoneId);
+    }
+    return { status: "not-gate" };
+}
+export function formatPendingAskUserQuestionsGateMessage(pendingGateId, interrupted) {
+    return [
+        `Waiting for depth confirmation on gate "${pendingGateId}".`,
+        interrupted
+            ? "The confirmation question was interrupted before a response was recorded."
+            : "No user response was received for the confirmation question.",
+        "Do not infer approval from earlier or prior messages.",
+        "Do not proceed, write files, save artifacts, or call other tools.",
+        `Re-call ask_user_questions with the same gate question id ("${pendingGateId}") and wait for the user's response.`,
+    ].join(" ");
+}
 export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queuePhaseActive, basePath = process.cwd()) {
     if (toolName !== "write")
         return { block: false };

package/dist/resources/extensions/gsd/closeout-consistency-gate.js

@@ -1,7 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Shared DB-backed guard for milestone closeout finalization.
-import { getDbPath, getLatestAssessmentByScope, getMilestone, getMilestoneSlices, getPendingGates, getSliceTasks, isDbAvailable, refreshOpenDatabaseFromDisk, } from "./gsd-db.js";
+import { dirname } from "node:path";
+import { getLatestAssessmentByScope, getMilestone, getMilestoneSlices, getPendingGates, getSliceTasks, isDbAvailable, } from "./gsd-db.js";
+import { getWorkflowDatabasePath, refreshWorkflowDatabaseFromDisk, } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
+import { closeQualityGatesFromEvidence } from "./quality-gate-closure.js";
 export const CLOSEOUT_CONSISTENCY_BLOCKED_REASON = "closeout-consistency-blocked";
 function blocked(reason, message) {
     return {
@@ -14,22 +17,30 @@ function blocked(reason, message) {
 function isFileBackedDbPath(path) {
     return Boolean(path && path !== ":memory:");
 }
+function artifactBasePathFromDb() {
+    const dbPath = getWorkflowDatabasePath();
+    if (!isFileBackedDbPath(dbPath))
+        return undefined;
+    return dirname(dirname(dbPath));
+}
 export function checkCloseoutConsistencyGate(milestoneId, options = {}) {
     if (!isDbAvailable()) {
         return blocked("db-unavailable", `Closeout consistency blocked for ${milestoneId}: canonical DB is unavailable.`);
     }
-    if (options.refreshFromDisk && isFileBackedDbPath(getDbPath()) && !refreshOpenDatabaseFromDisk()) {
+    if (options.refreshFromDisk && isFileBackedDbPath(getWorkflowDatabasePath()) && !refreshWorkflowDatabaseFromDisk()) {
         return blocked("db-refresh-failed", `Closeout consistency blocked for ${milestoneId}: canonical DB refresh failed.`);
     }
     const milestone = getMilestone(milestoneId);
     if (!milestone) {
         return blocked("milestone-missing", `Closeout consistency blocked for ${milestoneId}: milestone is missing from canonical DB.`);
     }
-    if (!isClosedStatus(milestone.status)) {
+    if (!isClosedStatus(milestone.status) && !options.allowOpenMilestone) {
         return blocked("milestone-open", `Closeout consistency blocked for ${milestoneId}: canonical DB milestone status is "${milestone.status}".`);
     }
+    const validation = milestone.status === "skipped"
+        ? null
+        : getLatestAssessmentByScope(milestoneId, "milestone-validation");
     if (milestone.status !== "skipped") {
-        const validation = getLatestAssessmentByScope(milestoneId, "milestone-validation");
         if (validation?.status !== "pass") {
             return blocked("validation-not-pass", `Closeout consistency blocked for ${milestoneId}: latest milestone validation is "${validation?.status ?? "absent"}".`);
         }
@@ -38,6 +49,12 @@ export function checkCloseoutConsistencyGate(milestoneId, options = {}) {
     if (slices.length === 0 && milestone.status !== "skipped") {
         return blocked("slice-missing", `Closeout consistency blocked for ${milestoneId}: no slices exist in canonical DB.`);
     }
+    if (milestone.status !== "skipped") {
+        closeQualityGatesFromEvidence(milestoneId, {
+            artifactBasePath: options.artifactBasePath ?? artifactBasePathFromDb(),
+            milestoneValidationPassed: validation?.status === "pass",
+        });
+    }
     for (const slice of slices) {
         if (!isClosedStatus(slice.status)) {
             return blocked("slice-open", `Closeout consistency blocked for ${milestoneId}: slice ${slice.id} status is "${slice.status}".`);

package/dist/resources/extensions/gsd/codebase-generator.js

@@ -330,15 +330,19 @@ export function ensureCodebaseMapFresh(basePath, options, ensureOptions) {
     const ttlMs = ensureOptions?.ttlMs ?? DEFAULT_REFRESH_TTL_MS;
     const force = ensureOptions?.force === true;
     const now = Date.now();
+    // Enumerate files and compute fingerprint before the TTL check so that
+    // file changes are always detected, even within the TTL window.
+    const existing = readCodebaseMap(basePath);
+    const listed = enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
+    const fingerprint = computeCodebaseFingerprint(listed.files, resolved, listed.truncated);
+    // TTL short-circuit: only bypass regeneration when the fingerprint matches,
+    // confirming that no tracked files changed since the last check.
     if (!force && ttlMs > 0) {
         const cached = freshnessCache.get(cacheKey);
-        if (cached && now - cached.checkedAt < ttlMs) {
+        if (cached && now - cached.checkedAt < ttlMs && cached.result.fingerprint === fingerprint) {
             return cached.result;
         }
     }
-    const existing = readCodebaseMap(basePath);
-    const listed = enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
-    const fingerprint = computeCodebaseFingerprint(listed.files, resolved, listed.truncated);
     const cacheAndReturn = (result) => {
         freshnessCache.set(cacheKey, { checkedAt: now, result });
         return result;

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

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { enableDebug } from "../../debug-logger.js";
 import { isAutoActive, isAutoPaused, pauseAuto, startAutoDetached, stopAuto, stopAutoRemote } from "../../auto.js";
 import { handleRate } from "../../commands-rate.js";
+import { notifyPreferenceDiagnostics } from "../../preferences-diagnostics.js";
 import { setSessionModelOverride } from "../../session-model-override.js";
 import { guardRemoteSession, projectRoot } from "../context.js";
 import { findMilestoneIds } from "../../milestone-id-utils.js";
@@ -82,6 +83,7 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
         const basePath = projectRoot();
         if (await hasUnresolvedCloseoutBlocker(ctx, basePath))
             return true;
+        notifyPreferenceDiagnostics(ctx, basePath, { surface: "auto-preflight" });
         // Validate the milestone target exists and is not already complete.
         if (milestoneId) {
             const allIds = findMilestoneIds(basePath);
@@ -109,6 +111,7 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
         const basePath = projectRoot();
         if (await hasUnresolvedCloseoutBlocker(ctx, basePath))
             return true;
+        notifyPreferenceDiagnostics(ctx, basePath, { surface: "auto-preflight" });
         // Validate the milestone target exists and is not already complete.
         if (milestoneId) {
             const allIds = findMilestoneIds(basePath);

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

@@ -19,6 +19,7 @@ import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { currentDirectoryRoot, projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { buildClaudeRuntimeFloorAdvisory } from "../../shared/claude-runtime-floor.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";
@@ -52,6 +53,21 @@ function resolveInstallCommand(pkg) {
         return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
+function notifyClaudeRuntimeFloorAdvisory(ctx) {
+    let advisory = null;
+    try {
+        advisory = buildClaudeRuntimeFloorAdvisory({
+            agentDir: join(gsdHome(), "agent"),
+            cwd: process.cwd(),
+        });
+    }
+    catch {
+        return;
+    }
+    if (advisory) {
+        ctx.ui.notify(advisory, "warning");
+    }
+}
 async function fetchLatestVersionForCommand(registryUrl = UPDATE_REGISTRY_URL) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), UPDATE_FETCH_TIMEOUT_MS);
@@ -458,6 +474,8 @@ export async function handleUpdate(ctx, args = "") {
     }
     if (current && compareSemverLocal(latest, current) <= 0) {
         ctx.ui.notify(`Already up to date (${formatCommandVersion(current)}).`, "info");
+        if (!browserUpdate)
+            notifyClaudeRuntimeFloorAdvisory(ctx);
         return;
     }
     ctx.ui.notify(`Updating: ${formatCommandVersion(current)} → v${latest}...`, "info");
@@ -472,6 +490,8 @@ export async function handleUpdate(ctx, args = "") {
             ? `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");
+        if (!browserUpdate)
+            notifyClaudeRuntimeFloorAdvisory(ctx);
     }
     catch {
         ctx.ui.notify(`Update failed. Try manually: ${installCmd}`, "error");

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

@@ -3,9 +3,7 @@
  *
  * Contains: InspectData type, formatInspectOutput, handleInspect
  */
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
+import { isWorkflowDatabaseOpen, openExistingWorkflowDatabase, } from "./db-workspace.js";
 import { logWarning } from "./workflow-logger.js";
 import { getErrorMessage } from "./error-utils.js";
 export function formatInspectOutput(data) {
@@ -34,11 +32,9 @@ export function formatInspectOutput(data) {
 }
 export async function handleInspect(ctx) {
     try {
-        const { isDbAvailable, _getAdapter, openDatabase } = await import("./gsd-db.js");
-        if (!isDbAvailable()) {
-            const gsdDir = gsdRoot(process.cwd());
-            const dbPath = join(gsdDir, "gsd.db");
-            if (!existsSync(gsdDir) || !existsSync(dbPath) || !openDatabase(dbPath)) {
+        const { _getAdapter } = await import("./gsd-db.js");
+        if (!isWorkflowDatabaseOpen()) {
+            if (!openExistingWorkflowDatabase(process.cwd()).ok) {
                 ctx.ui.notify("No GSD database available. Run /gsd auto to create one.", "info");
                 return;
             }

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

@@ -9,6 +9,7 @@ import { deriveState } from "./state.js";
 import { gsdProjectionRoot, gsdRoot } from "./paths.js";
 import { nativeBranchList, nativeDetectMainBranch, nativeBranchListMerged, nativeBranchDelete, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
 import { logWarning } from "./workflow-logger.js";
+import { backupWorkflowDatabaseSnapshot, refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 export async function handleCleanupBranches(ctx, basePath) {
     let branches;
     try {
@@ -511,7 +512,7 @@ async function confirmRecover(ctx, args, markdown, beforeDb, dataLoss) {
  * Prints counts of recovered items and the resulting project phase.
  */
 export async function handleRecover(ctx, basePath, args = "") {
-    const { isDbAvailable: dbAvailable, clearEngineHierarchy, transaction: dbTransaction, backupDatabaseSnapshot } = await import("./gsd-db.js");
+    const { isDbAvailable: dbAvailable, clearEngineHierarchy, transaction: dbTransaction } = await import("./gsd-db.js");
     const { migrateHierarchyToDb } = await import("./md-importer.js");
     const { invalidateStateCache } = await import("./state.js");
     const { countDbHierarchy, countMarkdownHierarchy, recoverWouldDeleteDbRows } = await import("./migration-auto-check.js");
@@ -531,7 +532,7 @@ export async function handleRecover(ctx, basePath, args = "") {
         return;
     try {
         // 0. Snapshot the DB before the destructive clear so recover is reversible.
-        const backupPath = backupDatabaseSnapshot("pre-recover");
+        const backupPath = backupWorkflowDatabaseSnapshot("pre-recover");
         // 1. Delete + re-populate inside a single transaction for atomicity.
         //    clearEngineHierarchy() uses transaction() internally but transaction()
         //    is re-entrant, so wrapping in dbTransaction() keeps the whole
@@ -655,6 +656,49 @@ function parseRebuildTarget(args) {
         return "database";
     return "usage";
 }
+/**
+ * Re-render markdown planning projections from the authoritative DB.
+ *
+ * Quarantines open-unit SUMMARY files that contradict DB status before
+ * rendering. Safe to call after milestone merge/transition or during startup
+ * self-heal when the DB holds rows markdown lacks.
+ */
+export async function rebuildMarkdownProjectionsFromDb(basePath) {
+    const { deleteArtifactByPath } = await import("./gsd-db.js");
+    const { detectArtifactDbDrift } = await import("./state-reconciliation/drift/artifact-db.js");
+    const { renderAllFromDb } = await import("./markdown-renderer.js");
+    const { invalidateStateCache } = await import("./state.js");
+    invalidateStateCache();
+    refreshWorkflowDatabaseFromDisk();
+    const state = await deriveState(basePath);
+    const drifts = detectArtifactDbDrift(state, { basePath, state });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const quarantined = [];
+    const seen = new Set();
+    for (const drift of drifts) {
+        if (drift.kind !== "artifact-db-status-divergence")
+            continue;
+        if (drift.artifactType !== "SUMMARY" || !drift.artifactPath)
+            continue;
+        const absPath = resolveDiskArtifactPath(basePath, drift.artifactPath);
+        if (seen.has(absPath) || !existsSync(absPath))
+            continue;
+        seen.add(absPath);
+        const artifactDbPath = artifactPathForDb(basePath, absPath);
+        const target = quarantineProjectionFile(basePath, absPath, stamp);
+        deleteArtifactByPath(artifactDbPath);
+        quarantined.push(target);
+    }
+    const rendered = await renderAllFromDb(basePath);
+    invalidateStateCache();
+    return {
+        rendered: rendered.rendered,
+        skipped: rendered.skipped,
+        errors: rendered.errors,
+        quarantined: quarantined.length,
+        quarantinedPaths: quarantined,
+    };
+}
 /**
  * `gsd rebuild markdown` — Re-render markdown projections from the authoritative DB.
  *
@@ -663,10 +707,7 @@ function parseRebuildTarget(args) {
  * under `.gsd/quarantine/projections/` before DB projections are rendered.
  */
 export async function handleRebuild(ctx, basePath, args = "") {
-    const { isDbAvailable: dbAvailable, deleteArtifactByPath } = await import("./gsd-db.js");
-    const { detectArtifactDbDrift } = await import("./state-reconciliation/drift/artifact-db.js");
-    const { renderAllFromDb } = await import("./markdown-renderer.js");
-    const { invalidateStateCache } = await import("./state.js");
+    const { isDbAvailable: dbAvailable } = await import("./gsd-db.js");
     const target = parseRebuildTarget(args);
     if (target === "usage") {
         ctx.ui.notify([
@@ -690,53 +731,32 @@ export async function handleRebuild(ctx, basePath, args = "") {
         return;
     }
     try {
-        invalidateStateCache();
-        const state = await deriveState(basePath);
-        const drifts = detectArtifactDbDrift(state, { basePath, state });
-        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const quarantined = [];
-        const seen = new Set();
-        for (const drift of drifts) {
-            if (drift.kind !== "artifact-db-status-divergence")
-                continue;
-            if (drift.artifactType !== "SUMMARY" || !drift.artifactPath)
-                continue;
-            const absPath = resolveDiskArtifactPath(basePath, drift.artifactPath);
-            if (seen.has(absPath) || !existsSync(absPath))
-                continue;
-            seen.add(absPath);
-            const artifactDbPath = artifactPathForDb(basePath, absPath);
-            const target = quarantineProjectionFile(basePath, absPath, stamp);
-            deleteArtifactByPath(artifactDbPath);
-            quarantined.push(target);
-        }
-        const rendered = await renderAllFromDb(basePath);
-        invalidateStateCache();
+        const result = await rebuildMarkdownProjectionsFromDb(basePath);
         const lines = [
             "gsd rebuild markdown: rebuilt markdown projections from the canonical DB",
-            `  Rendered:    ${rendered.rendered}`,
-            `  Skipped:     ${rendered.skipped}`,
-            `  Quarantined: ${quarantined.length}`,
+            `  Rendered:    ${result.rendered}`,
+            `  Skipped:     ${result.skipped}`,
+            `  Quarantined: ${result.quarantined}`,
         ];
-        if (rendered.errors.length > 0) {
-            lines.push(`  Errors:      ${rendered.errors.length}`);
-            for (const err of rendered.errors.slice(0, 5)) {
+        if (result.errors.length > 0) {
+            lines.push(`  Errors:      ${result.errors.length}`);
+            for (const err of result.errors.slice(0, 5)) {
                 lines.push(`    - ${err}`);
             }
-            if (rendered.errors.length > 5) {
-                lines.push(`    - ${rendered.errors.length - 5} more`);
+            if (result.errors.length > 5) {
+                lines.push(`    - ${result.errors.length - 5} more`);
             }
         }
-        if (quarantined.length > 0) {
+        if (result.quarantined > 0) {
             lines.push("", "  Quarantine:");
-            for (const target of quarantined.slice(0, 5)) {
+            for (const target of result.quarantinedPaths.slice(0, 5)) {
                 lines.push(`    - ${target}`);
             }
-            if (quarantined.length > 5) {
-                lines.push(`    - ${quarantined.length - 5} more`);
+            if (result.quarantined > 5) {
+                lines.push(`    - ${result.quarantined - 5} more`);
             }
         }
-        ctx.ui.notify(lines.join("\n"), rendered.errors.length > 0 ? "warning" : "success");
+        ctx.ui.notify(lines.join("\n"), result.errors.length > 0 ? "warning" : "success");
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

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

@@ -10,7 +10,7 @@ import { nativeGetCurrentBranch, nativeDetectMainBranch } from "./native-git-bri
 import { formatDuration } from "../shared/format-utils.js";
 import { parseEvalReviewFrontmatter } from "./eval-review-schema.js";
 import { currentDirectoryRoot } from "./commands/context.js";
-import { buildPrEvidence } from "./pr-evidence.js";
+import { buildPullRequestEvidence } from "./pull-request-process.js";
 function git(basePath, args) {
     return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
 }
@@ -140,7 +140,7 @@ function generatePRContent(basePath, milestoneId, milestoneTitle) {
             metrics.push(`**Models:** ${byModel.map((m) => `${m.model} (${m.units} units)`).join(", ")}`);
         }
     }
-    return buildPrEvidence({
+    return buildPullRequestEvidence({
         milestoneId,
         milestoneTitle,
         changeType: "feat",

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

@@ -1,11 +1,14 @@
 // Project/App: gsd-pi
 // File Purpose: Handles manual milestone validation verdict overrides.
 import { loadFile } from "./files.js";
-import { resolveMilestoneFile } from "./paths.js";
+import { gsdProjectionRoot, resolveMilestoneFile } from "./paths.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { join } from "node:path";
 import { deriveState } from "./state.js";
 import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getLatestAssessmentByScope } from "./gsd-db.js";
+import { checkpointWorkflowDatabase } from "./db-workspace.js";
 import { VALIDATION_VERDICTS, extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
 const USAGE = 'Usage: /gsd verdict <pass|needs-attention|needs-remediation> [--milestone Mxxx] [--rationale "..."]';
 function tokenize(raw) {
@@ -86,8 +89,14 @@ export function parseValidationFile(content) {
     };
 }
 async function loadExistingValidation(basePath, milestoneId) {
+    const canonicalBase = resolveCanonicalMilestoneRoot(basePath, milestoneId);
+    const canonicalValidationPath = join(gsdProjectionRoot(canonicalBase), "milestones", milestoneId, `${milestoneId}-VALIDATION.md`);
+    const canonicalContent = await loadFile(canonicalValidationPath);
+    if (canonicalContent) {
+        return { content: canonicalContent, source: canonicalValidationPath };
+    }
     const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
-    if (validationPath) {
+    if (validationPath && validationPath !== canonicalValidationPath) {
         const content = await loadFile(validationPath);
         if (content)
             return { content, source: validationPath };
@@ -157,6 +166,7 @@ export async function handleVerdict(rawArgs, ctx, basePath) {
         ctx.ui.notify(msg, "error");
         return;
     }
+    checkpointWorkflowDatabase();
     const prevVerdict = current.verdict ?? "unknown";
     const effectiveVerdict = extractEffectiveVerdict(result.details, parsed.verdict);
     if (effectiveVerdict !== parsed.verdict) {

package/dist/resources/extensions/gsd/db-workspace.js

@@ -0,0 +1,103 @@
+// Project/App: gsd-pi
+// File Purpose: Workspace-facing Interface for opening and maintaining the workflow database.
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import { backupDatabaseSnapshot, checkpointDatabase, closeAllDatabases, closeDatabase, closeDatabaseByWorkspace, getDbPath, getDbStatus, getDbProvider, isDbAvailable, openDatabase, openDatabaseByScope, openDatabaseByWorkspace, refreshOpenDatabaseFromDisk, vacuumDatabase, wasDbOpenAttempted, } from "./gsd-db.js";
+import { resolveGsdPathContract } from "./paths.js";
+import { setLogBasePath } from "./workflow-logger.js";
+export function resolveWorkflowDatabaseLocation(basePath) {
+    const contract = resolveGsdPathContract(basePath);
+    return {
+        projectRoot: dirname(dirname(contract.projectDb)),
+        projectGsd: contract.projectGsd,
+        projectDb: contract.projectDb,
+    };
+}
+/**
+ * Resolve the correct DB path for the current working directory.
+ * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
+ * the project root's `.gsd/gsd.db` (shared WAL — R012). Otherwise returns
+ * `<basePath>/.gsd/gsd.db`.
+ */
+export function resolveProjectRootDbPath(basePath) {
+    return resolveWorkflowDatabaseLocation(basePath).projectDb;
+}
+export function openWorkflowDatabase(basePath) {
+    const location = resolveWorkflowDatabaseLocation(basePath);
+    if (!existsSync(location.projectGsd)) {
+        return { ok: false, reason: "missing-gsd-dir", location };
+    }
+    const existed = existsSync(location.projectDb);
+    try {
+        const opened = openDatabase(location.projectDb);
+        if (!opened) {
+            return { ok: false, reason: "open-failed", location };
+        }
+        setLogBasePath(location.projectRoot);
+        return {
+            ok: true,
+            reason: existed ? "opened-existing" : "created-empty",
+            location,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: "open-failed",
+            location,
+            error: err instanceof Error ? err : new Error(String(err)),
+        };
+    }
+}
+export function openExistingWorkflowDatabase(basePath) {
+    const location = resolveWorkflowDatabaseLocation(basePath);
+    if (!existsSync(location.projectDb)) {
+        return { ok: false, reason: "missing-database", location };
+    }
+    return openWorkflowDatabase(basePath);
+}
+export function openWorkflowDatabasePath(path) {
+    return openDatabase(path);
+}
+export function openWorkflowDatabaseByWorkspace(workspace) {
+    return openDatabaseByWorkspace(workspace);
+}
+export function openWorkflowDatabaseByScope(scope) {
+    return openDatabaseByScope(scope);
+}
+export function closeWorkflowDatabase() {
+    closeDatabase();
+}
+export function closeWorkflowDatabaseByWorkspace(workspace) {
+    closeDatabaseByWorkspace(workspace);
+}
+export function closeAllWorkflowDatabases() {
+    closeAllDatabases();
+}
+export function isWorkflowDatabaseOpen() {
+    return isDbAvailable();
+}
+export function wasWorkflowDatabaseOpenAttempted() {
+    return wasDbOpenAttempted();
+}
+export function getWorkflowDatabaseStatus() {
+    return getDbStatus();
+}
+export function getWorkflowDatabaseProvider() {
+    return getDbProvider();
+}
+export function getWorkflowDatabasePath() {
+    return getDbPath();
+}
+export function refreshWorkflowDatabaseFromDisk() {
+    return refreshOpenDatabaseFromDisk();
+}
+export function checkpointWorkflowDatabase() {
+    checkpointDatabase();
+}
+export function vacuumWorkflowDatabase() {
+    vacuumDatabase();
+}
+export function backupWorkflowDatabaseSnapshot(label) {
+    return backupDatabaseSnapshot(label);
+}

package/dist/resources/extensions/gsd/debug-logger.js

@@ -21,6 +21,7 @@ const _counters = {
     parsePlanTotalMs: 0,
     dispatches: 0,
     renders: 0,
+    gitInvocations: 0,
 };
 /** Max debug log files to keep. Older ones are pruned on enable. */
 const MAX_DEBUG_LOGS = 5;
@@ -118,6 +119,14 @@ export function debugCount(counter, value = 1) {
         return;
     _counters[counter] += value;
 }
+/**
+ * Snapshot the current debug counters. Used by the per-dispatch benchmark
+ * harness (#442) to read counts without disabling debug (which is what
+ * writeDebugSummary does). Returns a copy so callers can't mutate internal state.
+ */
+export function getDebugCounters() {
+    return { ..._counters };
+}
 /** Record a peak value (only updates if new value is higher). */
 export function debugPeak(counter, value) {
     if (!_enabled)
@@ -154,6 +163,7 @@ export function writeDebugSummary() {
         avgTtsrCheck_ms,
         ttsrPeakBuffer: _counters.ttsrPeakBuffer,
         renders: _counters.renders,
+        gitInvocations: _counters.gitInvocations,
     });
     return disableDebug();
 }

package/dist/resources/extensions/gsd/delegation-policy.js

@@ -34,6 +34,7 @@
 // Adding a `unitType` mapping (or a future `unitTypes: string[]`) to an
 // existing entry is the place to lift any of these out of default-deny
 // when the analysis has been done.
+import { canonicalWorkflowSurfaceToolName } from "./workflow-tool-surface.js";
 const POLICY = {
     gsd_plan_slice: {
         toolName: "gsd_plan_slice",
@@ -96,17 +97,8 @@ const POLICY = {
         rationale: "plan-slice prompt explicitly forbids calling gsd_plan_task separately; per-task granularity multiplies manifest writes and projection re-renders with no payoff.",
     },
 };
-// Alias map keyed on the secondary name; resolves to the canonical entry above.
-// Sourced from packages/mcp-server/src/workflow-tools.ts alias registrations
-// (gsd_milestone_validate, gsd_roadmap_reassess, gsd_slice_replan, gsd_task_plan).
-const ALIASES = {
-    gsd_milestone_validate: "gsd_validate_milestone",
-    gsd_roadmap_reassess: "gsd_reassess_roadmap",
-    gsd_slice_replan: "gsd_replan_slice",
-    gsd_task_plan: "gsd_plan_task",
-};
 function resolveCanonical(name) {
-    return ALIASES[name] ?? name;
+    return canonicalWorkflowSurfaceToolName(name);
 }
 export function getDelegationVerdict(toolName) {
     return POLICY[resolveCanonical(toolName)] ?? null;