@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

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-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-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/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";
+    });
+}