@opengsd/gsd-pi 1.2.0-dev.84c56d87 → 1.2.0-dev.8e6112e9

package/dist/resources/extensions/gsd/closeout-wizard.js

@@ -1,22 +1,107 @@
 // Project/App: gsd-pi
 // File Purpose: Shared closeout detection and merge actions for /gsd home and smart entry.
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
 import { setAutoOutcomeWidget } from "./auto-dashboard.js";
 import { invalidateAllCaches } from "./cache.js";
+import { isDbAvailable } from "./db/engine.js";
+import { getMilestone } from "./db/queries.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { mergeCompletedMilestone } from "./parallel-merge.js";
 import { cleanupQuickBranch, detectStrandedQuickBranch } from "./quick.js";
+import { isClosedStatus } from "./status-guards.js";
 import { findUnmergedCompletedMilestones, } from "./unmerged-milestone-guard.js";
 import { appendRequirementsBacklogToSummary } from "./requirements-backlog.js";
+import { nativeBranchList, nativeIsRepo } from "./native-git-bridge.js";
+import { allWorktreesDirs } from "./worktree-manager.js";
 const MILESTONE_MERGE_CLOSEOUT_COMMANDS = [
     "/gsd status for overview",
     "/gsd visualize to inspect",
     "/gsd notifications for history",
     "/gsd start for new work",
 ];
+function listMilestoneWorktreeIds(basePath) {
+    const ids = new Set();
+    for (const wtDir of allWorktreesDirs(basePath)) {
+        if (!existsSync(wtDir))
+            continue;
+        for (const entry of readdirSync(wtDir)) {
+            if (!MILESTONE_ID_RE.test(entry))
+                continue;
+            try {
+                if (statSync(join(wtDir, entry)).isDirectory())
+                    ids.add(entry);
+            }
+            catch {
+                // skip unreadable entries
+            }
+        }
+    }
+    return [...ids].sort();
+}
+function listMilestoneBranchIds(basePath) {
+    try {
+        return nativeBranchList(basePath, "milestone/*")
+            .map((branch) => branch.replace(/^milestone\//, ""))
+            .filter((id) => MILESTONE_ID_RE.test(id))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * A milestone ID is "stranded residue" only when its worktree/branch artifacts
+ * exist for a milestone the DB does not consider currently in flight — i.e. the
+ * row is closed (complete/done/skipped/closed) or absent. Active, pending,
+ * blocked, parked, queued, and deferred rows describe normal in-flight or
+ * intentionally-preserved state, never residue. Returning `false` skips the ID;
+ * returning `true` keeps it in the hint.
+ */
+function isStrandedMilestoneId(milestoneId) {
+    if (!isDbAvailable())
+        return true;
+    const row = getMilestone(milestoneId);
+    if (!row)
+        return true;
+    return isClosedStatus(row.status);
+}
+/** Surface stranded milestone git residue when closeout guards did not classify it. */
+export function detectIdleMilestoneResidueHint(basePath) {
+    if (!nativeIsRepo(basePath))
+        return null;
+    const gsdDir = join(basePath, ".gsd");
+    const dbPath = join(gsdDir, "gsd.db");
+    if (!existsSync(gsdDir) || !existsSync(dbPath)) {
+        return {
+            milestoneIds: [],
+            message: "This git repo has no local GSD workflow database (.gsd/gsd.db). " +
+                "Workflow state may live in an external worktree, or run /gsd new-project to initialize here.",
+        };
+    }
+    const worktreeIds = listMilestoneWorktreeIds(basePath);
+    const branchIds = listMilestoneBranchIds(basePath);
+    const candidateIds = [...new Set([...worktreeIds, ...branchIds])].sort();
+    const milestoneIds = candidateIds.filter(isStrandedMilestoneId);
+    if (milestoneIds.length === 0)
+        return null;
+    const listed = milestoneIds.join(", ");
+    const recovery = milestoneIds.length === 1
+        ? `/gsd dispatch complete-milestone ${milestoneIds[0]}`
+        : "/gsd doctor --fix";
+    return {
+        milestoneIds,
+        message: `Stranded milestone git residue detected (${listed}: worktree dir and/or milestone/* branch). ` +
+            `Run ${recovery} or /gsd status to recover closeout before starting new work.`,
+    };
+}
 export async function loadCloseoutContext(basePath) {
     const unmergedMilestones = await findUnmergedCompletedMilestones(basePath);
+    const idleResidueHint = unmergedMilestones.length === 0 ? detectIdleMilestoneResidueHint(basePath) : null;
     return {
         strandedQuick: detectStrandedQuickBranch(basePath),
         unmergedMilestones,
+        idleResidueHint,
     };
 }
 export function getPrimaryCloseoutRecommendation(closeout) {
@@ -62,6 +147,13 @@ export function buildIdleMenuSummary(state, closeout) {
             `${blocker.milestoneId} is complete but not merged into ${blocker.integrationBranch}.`,
         ];
     }
+    // Surface idle residue before the completion summary so smart entry shows
+    // the same recovery text /gsd home would: a closed/unknown milestone with
+    // lingering worktree/branch artifacts must not be hidden behind the
+    // "all milestones complete" message.
+    if (closeout.idleResidueHint) {
+        return [closeout.idleResidueHint.message];
+    }
     if (state.phase === "complete") {
         const last = state.lastCompletedMilestone;
         return appendRequirementsBacklogToSummary(state, [

package/dist/resources/extensions/gsd/commands/context.js

@@ -1,4 +1,4 @@
-import { checkRemoteAutoSession, isAutoActive, isAutoPaused, stopAutoRemote } from "../auto.js";
+import { checkRemoteAutoSession, forceStopAutoRemote, isAutoActive, isAutoPaused, stopAutoRemote } from "../auto.js";
 import { validateDirectory } from "../validate-directory.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { showNextAction } from "../../shared/tui.js";
@@ -135,5 +135,19 @@ export async function guardRemoteSession(ctx, pi) {
         }
         return false;
     }
-    return choice === "force";
+    if (choice === "force") {
+        const result = forceStopAutoRemote(projectRoot());
+        if (result.error) {
+            ctx.ui.notify(`Failed to force-stop remote auto-mode: ${result.error}`, "error");
+            return false;
+        }
+        if (result.found) {
+            ctx.ui.notify(`Force-stopped auto-mode session (PID ${result.pid}). Starting a new session.`, "warning");
+        }
+        else {
+            ctx.ui.notify("Remote session is no longer running. Starting a new session.", "info");
+        }
+        return true;
+    }
+    return false;
 }

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

@@ -7,7 +7,7 @@
 import { existsSync, readFileSync, mkdirSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
-import { join, resolve as resolvePath, sep } from "node:path";
+import { join, resolve as resolvePath, sep, win32 as pathWin32 } from "node:path";
 import { homedir } from "node:os";
 import { deriveState } from "./state.js";
 import { gsdRoot } from "./paths.js";
@@ -20,6 +20,7 @@ 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 { reconcileGsdBrowserPathAfterInstall } from "../../shared/gsd-browser-path-sync.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";
@@ -51,8 +52,31 @@ function resolveInstallCommand(pkg) {
         return `bun add -g ${pkg}`;
     if (isPnpmInstall())
         return `pnpm add -g ${pkg}`;
+    const npmPrefix = resolveWindowsNpmGlobalPrefix();
+    if (npmPrefix)
+        return `npm --prefix ${quoteWindowsArg(npmPrefix)} install -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
+function resolveWindowsNpmGlobalPrefix(argv1 = process.argv[1], platform = process.platform) {
+    if (platform !== "win32" || !argv1)
+        return null;
+    const normalized = pathWin32.normalize(argv1);
+    const marker = `${pathWin32.sep}node_modules${pathWin32.sep}`;
+    const index = normalized.toLowerCase().lastIndexOf(marker);
+    if (index <= 0)
+        return null;
+    const prefix = normalized.slice(0, index);
+    // Verify this is a real npm global prefix: such a directory always contains
+    // npm's own bin shim (`npm.cmd`) as a sibling of `node_modules/`. Local
+    // project `node_modules/`, npx caches, and other non-global layouts do not,
+    // so without this check `--prefix` would target the wrong directory.
+    if (!existsSync(pathWin32.join(prefix, "npm.cmd")))
+        return null;
+    return prefix;
+}
+function quoteWindowsArg(value) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
 function notifyClaudeRuntimeFloorAdvisory(ctx) {
     let advisory = null;
     try {
@@ -484,11 +508,30 @@ export async function handleUpdate(ctx, args = "") {
         execSync(installCmd, {
             stdio: ["ignore", "pipe", "ignore"],
         });
+        let reconcile = null;
+        if (browserUpdate) {
+            try {
+                reconcile = reconcileGsdBrowserPathAfterInstall({
+                    latestVersion: latest,
+                    compareSemver: compareSemverLocal,
+                    resolvePathVersion: resolveGsdBrowserPathVersionForCommand,
+                });
+            }
+            catch {
+                // Reconciliation is best-effort: the install above already succeeded,
+                // so a reconcile failure must not flip the result to "Update failed".
+                reconcile = null;
+            }
+        }
         const newPathVersion = browserUpdate ? resolveGsdBrowserPathVersionForCommand() : null;
-        const pathReady = !browserUpdate || (!!newPathVersion && compareSemverLocal(newPathVersion, latest) >= 0);
+        const pathNote = browserUpdate && !(newPathVersion && compareSemverLocal(newPathVersion, latest) >= 0)
+            ? (reconcile?.message
+                ?? "Ensure the npm global bin directory is on your PATH so MCP automation uses the updated binary.")
+            : "";
         ctx.ui.notify(browserUpdate
             ? `Updated gsd-browser to v${latest}. Restart your GSD session to use the new browser automation version.` +
-                (pathReady ? "" : "\nNote: Ensure the npm global bin directory is on your PATH so MCP automation uses the updated binary.")
+                (reconcile?.action === "synced" && reconcile.message ? `\n${reconcile.message}` : "") +
+                (pathNote ? `\nNote: ${pathNote}` : "")
             : `Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
         if (!browserUpdate)
             notifyClaudeRuntimeFloorAdvisory(ctx);

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

@@ -59,7 +59,7 @@ export function formatMcpStatusReport(servers) {
                 : s.connected
                     ? `connected — ${s.toolCount} tools`
                     : s.available
-                        ? `available — ${s.toolCount} tools`
+                        ? `probe available — ${s.toolCount} tools`
                         : "disconnected";
         const warningText = s.envWarnings?.length ? ` — ${s.envWarnings.length} warning(s)` : "";
         lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}${warningText}`);
@@ -83,7 +83,7 @@ export function formatMcpServerDetail(server) {
         lines.push(`  Error:     ${server.error}`);
     }
     else if (server.connected || server.available) {
-        lines.push(`  Status:    ${server.connected ? "connected" : "available"}`);
+        lines.push(`  Status:    ${server.connected ? "connected" : "probe available"}`);
         lines.push(`  Tools:     ${server.toolCount}`);
         if (server.tools.length > 0) {
             lines.push("");

package/dist/resources/extensions/gsd/commands-workflow-templates.js

@@ -59,6 +59,13 @@ function datePrefix() {
     const dd = String(d.getDate()).padStart(2, "0");
     return `${yy}${mm}${dd}`;
 }
+export function isWorkflowStateComplete(state) {
+    if (state.completedAt)
+        return true;
+    return Array.isArray(state.phases) &&
+        state.phases.length > 0 &&
+        state.phases.every((phase) => phase.status === "completed");
+}
 /**
  * Write a STATE.json file to track workflow execution state.
  */
@@ -85,7 +92,7 @@ function writeWorkflowState(artifactDir, templateId, templateName, phases, descr
  * Scan all workflow artifact directories for in-progress STATE.json files.
  * Returns workflows that were started but not completed.
  */
-function findInProgressWorkflows(basePath) {
+export function findInProgressWorkflows(basePath) {
     const workflowsRoot = join(gsdRoot(basePath), "workflows");
     if (!existsSync(workflowsRoot))
         return [];
@@ -105,7 +112,7 @@ function findInProgressWorkflows(basePath) {
                 try {
                     const raw = readFileSync(statePath, "utf-8");
                     const state = JSON.parse(raw);
-                    if (!state.completedAt) {
+                    if (!isWorkflowStateComplete(state)) {
                         results.push(state);
                     }
                 }

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

@@ -0,0 +1,353 @@
+/**
+ * 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]);
+}
+/**
+ * Detect a plain-text "Next steps:" menu — numbered options with an "Other"
+ * choice — emitted as prose instead of a structured ask_user_questions call.
+ * Without this, auto-mode treats the menu as informational and loops on its
+ * own turn until tokens are exhausted (#454).
+ */
+export function hasPlainTextNextStepsMenu(lines) {
+    const nextStepsIndex = lines.findIndex((line) => /^next steps\s*:?$/i.test(line));
+    if (nextStepsIndex < 0)
+        return false;
+    const menuLines = lines.slice(nextStepsIndex + 1);
+    const numberedOptions = menuLines.filter((line) => /^\d+[.)]\s+\S/.test(line));
+    return numberedOptions.length >= 2 && numberedOptions.some((line) => /\bother\b/i.test(line));
+}
+// ── 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;
+    if (hasPlainTextNextStepsMenu(lines))
+        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";
+    });
+}