@opengsd/gsd-pi 1.2.0-dev.b1abb545 → 1.2.0-dev.d6c5343c

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-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/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/consent-question.js

@@ -0,0 +1,337 @@
+/**
+ * Consent Question module — the single home for the user-question lifecycle:
+ * classification → gating → answer validation → cancellation.
+ *
+ * Every question the assistant puts to a human is classified into a kind, and
+ * the kind alone decides the fail policy:
+ *
+ *   - "gate"          — mechanical write gates (depth verification, destructive
+ *                       confirm). Fail-closed; structural answer validation is
+ *                       delegated to the write-gate validators.
+ *   - "consent"       — approval/confirmation questions ("ready to write?",
+ *                       "is this correct?"). Fail-closed.
+ *   - "decision"      — explicit user decisions (research vs skip). Fail-closed.
+ *   - "informational" — anything that is not asking the user to consent or
+ *                       decide. Fail-open.
+ *
+ * Fail-closed means an empty/missing answer is NEVER treated as an answer —
+ * evaluateAnswer returns "waiting" so callers pause instead of proceeding.
+ * This fixes #528 (empty `selected` on a non-gate question used to pass
+ * through as a real answer) by construction.
+ *
+ * shouldPauseForQuestion replaces the old unit-type allowlist: a classified
+ * consent/decision question pauses regardless of unit type, including
+ * interactive mode where no unit is active. This fixes #682 (prose approval
+ * questions outside the 4 allowlisted discuss units rendered as un-gated
+ * prose menus) by construction.
+ */
+import { isGateQuestionId } from "./bootstrap/write-gate.js";
+import { evaluateGateAnswer, hasNotesValue, hasSelectedValue, } from "./consent-verdict.js";
+import { isDestructiveConfirmGateId } from "./safety/destructive-confirmation.js";
+/** Fail policy is derived from the kind — there is no per-question override. */
+export function failPolicyForKind(kind) {
+    return kind === "informational" ? "open" : "closed";
+}
+// ── Prose detectors (moved from user-input-boundary) ────────────────────────
+const REMOTE_QUESTION_FAILURE_RE = /(?:Remote (?:auth failed|questions failed|channel configured but returned no result|questions timed out|questions timed out or failed)|Failed to send questions via)/i;
+const APPROVAL_WAIT_RE = /\bwait(?:ing)?\s+for\s+(?:your\s+)?(?:confirmation|approval|input|response|answer)\b/i;
+const APPROVAL_QUESTION_RE = /\b(?:confirm|confirmation|approve|approval|approved|captured|correct|correctly|happy\s+with|ready\s+to\s+(?:write|save|proceed|ship)|(?:want|need)\s+to\s+adjust|should\s+I\s+(?:write|save|proceed)|do\s+you\s+want\s+me\s+to\s+(?:write|save|proceed)|ship\s+it)\b/i;
+const APPROVAL_RIGHT_QUESTION_RE = /\b(?:does|do|is|are|was|were|did)\b[^\n?]{0,120}\bright\b/i;
+const APPROVAL_CHANGE_QUESTION_RE = /\b(?:anything\s+else|anything|something)\s+to\s+(?:adjust|add|remove|reclassify)\b/i;
+const RESEARCH_DECISION_QUESTION_RE = /\b(?:research|skip)\b/i;
+const ASK_USER_QUESTIONS_CANCELLED_RE = /ask_user_questions was cancelled before receiving a response/i;
+/** Scan question-mark-terminated fragments of `text` against `patterns`. */
+function hasQuestionMatching(text, patterns) {
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] !== "?")
+            continue;
+        const previousBreak = Math.max(text.lastIndexOf("\n", i), text.lastIndexOf(".", i), text.lastIndexOf("!", i), text.lastIndexOf("?", i - 1));
+        const fragment = text.slice(previousBreak + 1, i + 1);
+        if (patterns.some((pattern) => pattern.test(fragment)))
+            return true;
+    }
+    return false;
+}
+export function hasApprovalQuestion(text) {
+    return hasQuestionMatching(text, [
+        APPROVAL_QUESTION_RE,
+        APPROVAL_RIGHT_QUESTION_RE,
+        APPROVAL_CHANGE_QUESTION_RE,
+    ]);
+}
+export function hasResearchDecisionQuestion(text) {
+    return hasQuestionMatching(text, [RESEARCH_DECISION_QUESTION_RE]);
+}
+// ── Message text extraction (moved from user-input-boundary) ────────────────
+function extractMessageText(msg, includeThinking) {
+    if (!msg || typeof msg !== "object")
+        return "";
+    const content = msg.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const typed = block;
+        if (typed.type === "text" && typeof typed.text === "string") {
+            parts.push(typed.text);
+        }
+        // Thinking blocks are internal reasoning, not user-visible — included only
+        // when the caller asks for the full transcript text.
+        if (includeThinking && typed.type === "thinking" && typeof typed.thinking === "string") {
+            parts.push(typed.thinking);
+        }
+    }
+    return parts.join("\n");
+}
+function lastAssistantMessageText(messages, includeThinking) {
+    if (!Array.isArray(messages))
+        return "";
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== "object")
+            continue;
+        if (msg.role !== "assistant")
+            continue;
+        const text = extractMessageText(msg, includeThinking).trim();
+        if (text)
+            return text;
+    }
+    return "";
+}
+export function lastAssistantText(messages) {
+    return lastAssistantMessageText(messages, true);
+}
+function lastAssistantVisibleText(messages) {
+    return lastAssistantMessageText(messages, false);
+}
+function anyMessageMatches(messages, patterns) {
+    if (!Array.isArray(messages))
+        return false;
+    return messages.some((msg) => {
+        if (!msg || typeof msg !== "object")
+            return false;
+        if (msg.role === "user")
+            return false;
+        const text = extractMessageText(msg, false);
+        return patterns.some((pattern) => pattern.test(text));
+    });
+}
+// ── Classification ──────────────────────────────────────────────────────────
+const APPROVAL_GATE_ID_RE = /^depth_verification_.+_confirm$/;
+/**
+ * Classify a question — structured (by id) or prose (by text) — into a kind.
+ *
+ * Structured questions with a recognized gate id are gates; every other
+ * structured question is asking the user something, so it classifies as
+ * consent (fail-closed). Prose classifies by the approval/decision detectors;
+ * prose that matches neither is informational (fail-open).
+ */
+export function classifyQuestion(input) {
+    if (isDestructiveConfirmGateId(input.id)) {
+        return { kind: "gate", gateSubKind: "destructive-confirm" };
+    }
+    if (typeof input.id === "string" && isGateQuestionId(input.id)) {
+        return {
+            kind: "gate",
+            gateSubKind: APPROVAL_GATE_ID_RE.test(input.id) ? "approval" : "depth-verification",
+        };
+    }
+    // Any other structured question is a real elicitation of the user.
+    if (typeof input.id === "string" || Array.isArray(input.options)) {
+        return { kind: "consent" };
+    }
+    const text = input.text ?? "";
+    if (input.unitType === "research-decision" && hasResearchDecisionQuestion(text)) {
+        return { kind: "decision" };
+    }
+    if (hasApprovalQuestion(text)) {
+        return { kind: "consent" };
+    }
+    return { kind: "informational" };
+}
+/**
+ * THE single policy point for whether a question's answer counts as answered.
+ *
+ * - cancelled rounds → "cancelled" for every kind.
+ * - gate: delegates to evaluateGateAnswer in the consent-verdict leaf — the
+ *   same verdict engine write-gate's applyAskUserQuestionsGateResult consumes;
+ *   confirm option → "verified", any other real selection → "declined",
+ *   empty/missing → "waiting" (fail-closed).
+ * - consent/decision: a non-empty selection or non-empty notes → "answered";
+ *   empty/missing → "waiting" (fail-closed; fixes #528).
+ * - informational: always "answered" (fail-open).
+ */
+export function evaluateAnswer(options) {
+    const { question, details } = options;
+    if (details.cancelled)
+        return "cancelled";
+    const { kind } = classifyQuestion({ id: question.id, options: question.options });
+    if (failPolicyForKind(kind) === "open")
+        return "answered";
+    if (kind === "gate") {
+        // Gates keep strict structural validation: only the confirmation option
+        // verifies; notes never satisfy a gate.
+        return evaluateGateAnswer(question, details);
+    }
+    const questionId = typeof question.id === "string" ? question.id : "";
+    const answer = details.response?.answers?.[questionId];
+    if (hasSelectedValue(answer?.selected))
+        return "answered";
+    // Notes-only is a real user utterance for consent/decision questions, but
+    // never for gates (handled above).
+    if (hasNotesValue(answer?.notes))
+        return "answered";
+    return "waiting";
+}
+const OUTCOME_PRECEDENCE = [
+    "cancelled",
+    "waiting",
+    "declined",
+    "verified",
+    "answered",
+];
+/**
+ * Evaluate a whole ask_user_questions round. The round outcome is the most
+ * blocking per-question outcome (cancelled > waiting > declined > verified >
+ * answered). An empty round with a response is "answered"; an empty round
+ * without a response is "waiting" only when cancelled is not set and there is
+ * nothing to validate — callers treat a missing response with no questions as
+ * a no-op, so it reports "answered" here.
+ */
+export function evaluateAskUserQuestionsRound(questions, details) {
+    if (details.cancelled)
+        return "cancelled";
+    let worst = "answered";
+    for (const question of questions) {
+        const outcome = evaluateAnswer({ question, details });
+        if (OUTCOME_PRECEDENCE.indexOf(outcome) < OUTCOME_PRECEDENCE.indexOf(worst)) {
+            worst = outcome;
+        }
+    }
+    return worst;
+}
+export function formatUnansweredConsentQuestionMessage(questions) {
+    const ids = questions
+        .map((question) => (typeof question.id === "string" ? question.id : null))
+        .filter((id) => Boolean(id));
+    return [
+        `ask_user_questions returned without a selection${ids.length ? ` for ${ids.join(", ")}` : ""}.`,
+        "An empty answer is not consent — do not infer approval or proceed.",
+        "Re-call ask_user_questions with the same question(s) and wait for the user's response.",
+    ].join(" ");
+}
+// ── Pause gating (replaces the unit-type allowlist) ─────────────────────────
+/**
+ * Shared preamble for the awaiting-input predicates: cancellation and remote
+ * delivery failures always pause (an undelivered question can never be
+ * answered, so proceeding would be fail-open), as does an explicit
+ * "waiting for your approval/input" phrase in the last assistant text.
+ *
+ * Returns `forced: true` when the boundary is unconditional, plus the last
+ * assistant visible text for the caller's own classification.
+ */
+function awaitingBoundary(messages) {
+    if (anyMessageMatches(messages, [ASK_USER_QUESTIONS_CANCELLED_RE, REMOTE_QUESTION_FAILURE_RE])) {
+        return { forced: true, text: "" };
+    }
+    const text = lastAssistantVisibleText(messages);
+    if (text && APPROVAL_WAIT_RE.test(text))
+        return { forced: true, text };
+    return { forced: false, text };
+}
+/**
+ * Decide whether the assistant should pause for a prose user question.
+ *
+ * Unlike the retired USER_APPROVAL_UNIT_TYPES allowlist, this pauses for any
+ * classified consent/decision question regardless of unit type — including
+ * interactive mode where no unit is active (#682).
+ */
+export function shouldPauseForQuestion(unitType, messages) {
+    const { forced, text } = awaitingBoundary(messages);
+    if (forced)
+        return true;
+    // Streaming hot path: this runs on every message_update for every unit type.
+    // The classifiers only ever match question-mark-terminated fragments, so
+    // text without a "?" can never classify as consent/decision — bail before
+    // the multi-regex scan.
+    if (!text || !text.includes("?"))
+        return false;
+    const { kind } = classifyQuestion({ text, unitType });
+    return kind === "consent" || kind === "decision";
+}
+// ── Awaiting-input boundaries (moved from user-input-boundary) ──────────────
+export function isAwaitingUserInput(messages) {
+    const { forced, text } = awaitingBoundary(messages);
+    if (forced)
+        return true;
+    if (!text)
+        return false;
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (lines.some((line) => line.endsWith("?")))
+        return true;
+    return hasApprovalQuestion(text);
+}
+export function isAwaitingApprovalBoundary(messages) {
+    // With no unit type, classification reduces to the approval detectors —
+    // exactly the approval boundary.
+    return shouldPauseForQuestion(undefined, messages);
+}
+// ── Approval gate ids + explicit responses (moved from user-input-boundary) ─
+export function approvalGateIdForUnit(unitType, unitId) {
+    if (!unitType)
+        return null;
+    if (unitType === "discuss-project")
+        return "depth_verification_project_confirm";
+    if (unitType === "discuss-requirements")
+        return "depth_verification_requirements_confirm";
+    if (unitType === "research-decision")
+        return "depth_verification_research_decision_confirm";
+    if (unitType === "discuss-milestone") {
+        const safeUnitId = typeof unitId === "string" && /^[A-Za-z0-9_-]+$/.test(unitId)
+            ? unitId
+            : "milestone";
+        return `depth_verification_${safeUnitId}_confirm`;
+    }
+    return null;
+}
+const CHANGE_REQUEST_RESPONSE_RE = /\b(?:no|nope|nah|not\s+yet|don't|do\s+not|change|add|remove|reclassify|adjust|clarify|missing|instead|but|however|wait|hold)\b/i;
+const APPROVAL_RESPONSE_RE = /^(?:y|yes|yeah|yep|approve|approved|confirm|confirmed|correct|right|looks\s+(?:good|right)|sounds\s+good|all\s+good|ok|okay|go\s+ahead|proceed|write\s+it|save\s+it|do\s+it)\b/i;
+const RESEARCH_DECISION_RESPONSE_RE = /^(?:research|run\s+research|do\s+research|skip|skip\s+research|no\s+research)\b/i;
+export function isExplicitApprovalResponse(input, pendingGateId) {
+    const text = input?.trim() ?? "";
+    if (!text)
+        return false;
+    if (pendingGateId?.includes("research_decision")) {
+        return RESEARCH_DECISION_RESPONSE_RE.test(text);
+    }
+    if (CHANGE_REQUEST_RESPONSE_RE.test(text))
+        return false;
+    return APPROVAL_RESPONSE_RE.test(text);
+}
+/** True when an assistant message already has an in-flight ask_user_questions tool call. */
+export function messageHasPendingAskUserQuestionsTool(message) {
+    if (!message || typeof message !== "object")
+        return false;
+    const content = message.content;
+    if (!Array.isArray(content))
+        return false;
+    return content.some((block) => {
+        if (!block || typeof block !== "object")
+            return false;
+        // Claude Code marks completion by attaching externalResult, not by setting state.
+        // Streaming blocks often carry no state; serverToolUse is the claude-code-cli MCP path.
+        const tool = block;
+        if (tool.type !== "toolCall" && tool.type !== "serverToolUse")
+            return false;
+        const name = String(tool.name ?? "").toLowerCase();
+        if (!name.includes("ask_user_questions"))
+            return false;
+        if (tool.externalResult !== undefined)
+            return false;
+        return tool.state !== "completed" && tool.state !== "done";
+    });
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Consent verdict leaf — the single per-question verdict engine shared by the
+ * write gate (bootstrap/write-gate.ts) and the Consent Question module
+ * (consent-question.ts).
+ *
+ * This module is a dependency leaf on purpose: write-gate consumes
+ * evaluateGateAnswer here while consent-question imports write-gate's id
+ * predicates, so putting the verdict anywhere else would create an import
+ * cycle. It must not import from either module (ADR-039).
+ */
+/**
+ * Check whether a depth_verification answer confirms the discussion is complete.
+ * Uses structural validation: the selected answer must exactly match the first
+ * option label from the question definition (the confirmation option by convention).
+ * This rejects free-form "Other" text, decline options, and garbage input without
+ * coupling to any specific label substring.
+ *
+ * @param selected  The answer's selected value from details.response.answers[id].selected
+ * @param options   The question's options array from event.input.questions[n].options
+ */
+export function isDepthConfirmationAnswer(selected, options) {
+    const value = Array.isArray(selected) ? selected[0] : selected;
+    if (typeof value !== "string" || !value)
+        return false;
+    // If options are available, structurally validate: selected must exactly match
+    // the first option (confirmation) label. Rejects free-form "Other" and decline options.
+    if (Array.isArray(options) && options.length > 0) {
+        const confirmLabel = options[0]?.label;
+        return typeof confirmLabel === "string" && value === confirmLabel;
+    }
+    // Fail-closed: no options means we cannot structurally validate the answer.
+    // Returning false prevents any free-form string from unlocking the gate.
+    return false;
+}
+export function hasSelectedValue(selected) {
+    if (Array.isArray(selected)) {
+        return selected.some((value) => typeof value === "string" && value.length > 0);
+    }
+    return typeof selected === "string" && selected.length > 0;
+}
+export function hasNotesValue(notes) {
+    return typeof notes === "string" && notes.trim().length > 0;
+}
+/**
+ * THE per-question verdict for gate questions (fail-closed):
+ *
+ * - cancelled rounds → "cancelled".
+ * - the confirmation option (structural match) → "verified".
+ * - any other real selection → "declined".
+ * - empty/missing selection → "waiting" — an empty answer is NEVER an answer,
+ *   so notes can never satisfy a gate either.
+ */
+export function evaluateGateAnswer(question, details) {
+    if (details.cancelled)
+        return "cancelled";
+    const questionId = typeof question.id === "string" ? question.id : "";
+    const answer = details.response?.answers?.[questionId];
+    if (isDepthConfirmationAnswer(answer?.selected, question.options))
+        return "verified";
+    if (hasSelectedValue(answer?.selected))
+        return "declined";
+    return "waiting";
+}

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

@@ -6,8 +6,6 @@
 // ─── Timeouts ─────────────────────────────────────────────────────────────────
 /** Default timeout for verification-gate commands (ms). */
 export const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
-/** Default timeout for the dynamic bash tool (seconds). */
-export const DEFAULT_BASH_TIMEOUT_SECS = 120;
 // ─── Cache Sizes ──────────────────────────────────────────────────────────────
 /** Max directory-listing cache entries before eviction (#611). */
 export const DIR_CACHE_MAX = 200;

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -29,6 +29,7 @@ import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { getRuntimeKv, setRuntimeKv, deleteRuntimeKv } from "./db/runtime-kv.js";
 import { _getAdapter, isDbAvailable } from "./gsd-db.js";
 import { gsdRoot, normalizeRealPath } from "./paths.js";
+import { crashResumeHint } from "./guidance.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { effectiveLockFile } from "./session-lock.js";
 import { isInFlightRuntimePhase, listUnitRuntimeRecords } from "./unit-runtime.js";
@@ -289,18 +290,9 @@ export function formatCrashInfo(lock) {
         `  Started at: ${lock.unitStartedAt}`,
         `  PID: ${lock.pid}`,
     ];
-    if (lock.unitType === "starting" && lock.unitId === "bootstrap") {
-        lines.push(`No work was lost. Run /gsd auto to restart.`);
-    }
-    else if (lock.unitType.includes("research") || lock.unitType.includes("plan")) {
-        lines.push(`The ${lock.unitType} unit may be incomplete. Run /gsd auto to re-run it.`);
-    }
-    else if (lock.unitType.includes("execute")) {
-        lines.push(`Task execution was interrupted. Run /gsd auto to resume — completed work is preserved.`);
-    }
-    else if (lock.unitType.includes("complete")) {
-        lines.push(`Slice/milestone completion was interrupted. Run /gsd auto to finish.`);
-    }
+    const hint = crashResumeHint(lock.unitType, lock.unitId);
+    if (hint)
+        lines.push(hint);
     return lines.join("\n");
 }
 /**