@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.84c56d87

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

@@ -3,10 +3,12 @@ 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";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "../worktree-root.js";
+import { worktreesDirs } from "../worktree-placement.js";
 /**
  * Regex matching milestone CONTEXT.md file names in both legacy M001
  * and unique M001-abc123 formats. Exported so regex-hardening tests
@@ -102,10 +104,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).
@@ -216,6 +215,27 @@ export function loadWriteGateSnapshot(basePath) {
         return currentWriteGateSnapshot(basePath);
     }
 }
+/**
+ * Merge the persisted write-gate snapshot into the in-process Map entry.
+ * The workflow MCP server runs in a child process and records depth
+ * verification there; without this refresh the extension host keeps stale
+ * pending-gate memory and `activateDeferredApprovalGate` can re-arm a gate
+ * that the subprocess already cleared on disk.
+ *
+ * Returns the snapshot used for the refresh so callers that need to inspect
+ * it (e.g. re-arm guards) avoid a second disk read.
+ */
+export function refreshWriteGateStateFromDisk(basePath) {
+    const snapshot = loadWriteGateSnapshot(basePath);
+    if (!shouldPersistWriteGateSnapshot())
+        return snapshot;
+    const state = getWriteGateState(basePath);
+    state.pendingGateId = snapshot.pendingGateId;
+    state.activeQueuePhase = snapshot.activeQueuePhase;
+    state.verifiedDepthMilestones = new Set(snapshot.verifiedDepthMilestones);
+    state.verifiedApprovalGates = new Set(snapshot.verifiedApprovalGates ?? []);
+    return snapshot;
+}
 export function isDepthVerified(basePath = process.cwd()) {
     return getWriteGateState(basePath).verifiedDepthMilestones.size > 0;
 }
@@ -225,6 +245,7 @@ export function isDepthVerified(basePath = process.cwd()) {
 export function isMilestoneDepthVerified(milestoneId, basePath = process.cwd()) {
     if (!milestoneId)
         return false;
+    refreshWriteGateStateFromDisk(basePath);
     return getWriteGateState(basePath).verifiedDepthMilestones.has(milestoneId);
 }
 export function isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId) {
@@ -311,6 +332,7 @@ export function clearPendingGate(basePath) {
  * Get the currently pending gate, if any.
  */
 export function getPendingGate(basePath = process.cwd()) {
+    refreshWriteGateStateFromDisk(basePath);
     return getWriteGateState(basePath).pendingGateId;
 }
 /**
@@ -385,6 +407,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 };
@@ -860,10 +943,12 @@ export function shouldBlockWorktreeWrite(toolName, targetPath, effectiveBasePath
     const realTarget = realpathOrResolve(absTarget);
     const realRoot = realpathOrResolve(projectRoot);
     const realGsd = realpathOrResolve(join(projectRoot, ".gsd"));
-    const realWorktreesDir = realpathOrResolve(join(projectRoot, ".gsd", "worktrees"));
-    // Allow writes inside the legitimate worktrees subtree.
-    if (isPathContained(realTarget, realWorktreesDir))
-        return { block: false };
+    // Allow writes inside a legitimate worktrees subtree (canonical
+    // .gsd-worktrees/ or legacy .gsd/worktrees/).
+    for (const container of worktreesDirs(projectRoot)) {
+        if (isPathContained(realTarget, realpathOrResolve(container)))
+            return { block: false };
+    }
     // Allow writes to .gsd/ planning artifacts, but reject siblings whose name
     // starts with "worktrees" (the worktrees-extra prefix trick — case 4).
     if (isPathContained(realTarget, realGsd)) {

package/dist/resources/extensions/gsd/branch-patterns.js

@@ -11,3 +11,5 @@ export const SLICE_BRANCH_RE = /^gsd\/(?:([a-zA-Z0-9_-]+)\/)?(M\d+(?:-[a-z0-9]{6
 export const QUICK_BRANCH_RE = /^gsd\/quick\//;
 /** Matches GSD-generated workflow template branches, not arbitrary user gsd/* branches. */
 export const WORKFLOW_BRANCH_RE = /^gsd\/(?:hotfix|bugfix|small-feature|refactor|spike|security-audit|dep-upgrade|full-project)\//;
+/** Auto-mode milestone branch prefix: milestone/<MID>. */
+export const MILESTONE_BRANCH_PREFIX = "milestone/";

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

@@ -1,8 +1,14 @@
 // Project/App: gsd-pi
 // File Purpose: Shared browser-observable UAT requirement and evidence detection.
-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;
+import { BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES } from "../shared/browser-contract.js";
+// Alternation fragment over the contract's evidence-signal names, e.g.
+// `browser_(?:assert|batch|...)`. The names are `browser_`-prefixed
+// identifiers (pinned by tests/browser-contract.test.ts), so no escaping is
+// needed.
+const BROWSER_TOOL_SIGNAL = `browser_(?:${BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES.map((name) => name.slice("browser_".length)).join("|")})`;
+export const BROWSER_REQUIREMENT_RE = new RegExp(String.raw `\b(?:file://|localhost|playwright|chrome|screenshot|snapshot|${BROWSER_TOOL_SIGNAL})\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_RUNTIME_RE = new RegExp(String.raw `\b(?:browser|playwright|chrome|camoufox|${BROWSER_TOOL_SIGNAL}|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;

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

@@ -8,9 +8,10 @@
  * `.gsd/CAPTURES.md`, not the worktree's local `.gsd/`.
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
+import { join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { gsdRoot } from "./paths.js";
+import { projectRootFromWorktreePath } from "./worktree-root.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 const CAPTURES_FILENAME = "CAPTURES.md";
 const VALID_CLASSIFICATIONS = [
@@ -29,20 +30,9 @@ const VALID_CLASSIFICATIONS = [
  * directory that contains `.gsd/worktrees/` — that's the project root.
  */
 export function resolveCapturesPath(basePath) {
-    const resolved = resolve(basePath);
-    // Direct layout: /.gsd/worktrees/
-    const worktreeMarker = `${sep}.gsd${sep}worktrees${sep}`;
-    let idx = resolved.indexOf(worktreeMarker);
-    if (idx === -1) {
-        // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/
-        const symlinkRe = new RegExp(`\\${sep}\\.gsd\\${sep}projects\\${sep}[a-f0-9]+\\${sep}worktrees\\${sep}`);
-        const match = resolved.match(symlinkRe);
-        if (match && match.index !== undefined)
-            idx = match.index;
-    }
-    if (idx !== -1) {
-        // basePath is inside a worktree — resolve to project root
-        const projectRoot = resolved.slice(0, idx);
+    // If basePath is inside a worktree, resolve to the project root.
+    const projectRoot = projectRootFromWorktreePath(resolve(basePath));
+    if (projectRoot) {
         return join(projectRoot, ".gsd", CAPTURES_FILENAME);
     }
     return join(gsdRoot(basePath), CAPTURES_FILENAME);

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/closeout-recovery.js

@@ -2,12 +2,13 @@
 // File Purpose: Closeout git failure discovery, retry, and manual resolution helpers.
 import { execFileSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
+import { isAbsolute, resolve } from "node:path";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { runTurnGitAction } from "./git-service.js";
 import { _getAdapter, upsertTurnGitTransaction } from "./gsd-db.js";
 import { probeGitConflictState } from "./git-conflict-state.js";
 import { parseUnitId } from "./unit-id.js";
+import { worktreePathFor } from "./worktree-placement.js";
 function parseMetadata(value) {
     if (typeof value !== "string" || !value.trim())
         return {};
@@ -121,7 +122,7 @@ export function resolveCloseoutRecoveryBasePath(projectRoot, record) {
     const parsed = parseUnitId(record.unitId);
     const milestoneId = parsed.milestone ?? (/^M\d+(?:-[a-z0-9]{6})?/.exec(record.unitId)?.[0] ?? "");
     if (milestoneId) {
-        const worktreePath = existingRealPath(join(projectRoot, ".gsd", "worktrees", milestoneId));
+        const worktreePath = existingRealPath(worktreePathFor(projectRoot, milestoneId));
         if (worktreePath)
             return worktreePath;
     }

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/catalog.js

@@ -1,7 +1,8 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { gsdHome } from "../gsd-home.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { VISUAL_BRIEF_MODES } from "../../visual-brief/prompts.js";
 export const GSD_COMMAND_DESCRIPTION = "GSD — Git Ship Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|brief|report|queue|quick|discuss|capture|triage|dispatch|verdict|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|closeout|rebuild|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|memory|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|upgrade|fast|mcp|rethink|workflow|codebase|notifications|ship|do|usage|context|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
 export const TOP_LEVEL_SUBCOMMANDS = [
@@ -380,70 +381,13 @@ function getExtensionCompletions(prefix, action) {
         return [];
     }
 }
-function normalizePathForCompare(path) {
-    return path.replaceAll("\\", "/").replace(/\/+$/, "");
-}
-function findWorktreeSegment(normalizedPath) {
-    const directMarker = "/.gsd/worktrees/";
-    const directIdx = normalizedPath.indexOf(directMarker);
-    if (directIdx !== -1) {
-        return { gsdIdx: directIdx, afterWorktrees: directIdx + directMarker.length };
-    }
-    const symlinkMatch = normalizedPath.match(/\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//);
-    if (symlinkMatch?.index !== undefined) {
-        return { gsdIdx: symlinkMatch.index, afterWorktrees: symlinkMatch.index + symlinkMatch[0].length };
-    }
-    return null;
-}
-function resolveProjectRootFromGitFile(worktreePath) {
-    try {
-        let dir = worktreePath;
-        for (let i = 0; i < 30; i++) {
-            const gitPath = join(dir, ".git");
-            if (existsSync(gitPath)) {
-                const content = readFileSync(gitPath, "utf8").trim();
-                if (content.startsWith("gitdir: ")) {
-                    const gitDir = resolve(dir, content.slice(8));
-                    const dotGitDir = resolve(gitDir, "..", "..");
-                    if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
-                        return resolve(dotGitDir, "..");
-                    }
-                    const commonDirPath = join(gitDir, "commondir");
-                    if (existsSync(commonDirPath)) {
-                        const commonDir = readFileSync(commonDirPath, "utf8").trim();
-                        return resolve(resolve(gitDir, commonDir), "..");
-                    }
-                }
-                break;
-            }
-            const parent = resolve(dir, "..");
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    catch {
-        // Completion must stay best-effort.
-    }
-    return null;
-}
 function resolveProjectRootForCompletion(basePath) {
+    // Completion honors GSD_PROJECT_ROOT unconditionally (worker processes may
+    // complete from any cwd); resolveWorktreeProjectRoot only honors it for
+    // worktree paths.
     if (process.env.GSD_PROJECT_ROOT)
         return process.env.GSD_PROJECT_ROOT;
-    const normalizedPath = normalizePathForCompare(basePath);
-    const segment = findWorktreeSegment(normalizedPath);
-    if (!segment)
-        return basePath;
-    const separator = basePath.includes("\\") ? "\\" : "/";
-    const gsdMarker = `${separator}.gsd${separator}`;
-    const gsdIdx = basePath.indexOf(gsdMarker);
-    const candidate = gsdIdx !== -1 ? basePath.slice(0, gsdIdx) : basePath.slice(0, segment.gsdIdx);
-    const normalizedGsdHome = normalizePathForCompare(gsdHome());
-    const candidateGsdPath = normalizePathForCompare(join(candidate, ".gsd"));
-    if (candidateGsdPath === normalizedGsdHome || candidateGsdPath.startsWith(`${normalizedGsdHome}/`)) {
-        return resolveProjectRootFromGitFile(basePath) ?? basePath;
-    }
-    return candidate;
+    return resolveWorktreeProjectRoot(basePath);
 }
 export function getGsdArgumentCompletions(prefix) {
     const hasTrailingSpace = prefix.endsWith(" ");

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;
             }