@bridge4dev/runner 0.11.0 → 0.22.1

package/dist/adapters/codex.d.ts

@@ -1,6 +1,6 @@
 import { type CodexHome } from './codex-home.js';
 import { AppServerClient, type ServerRequest } from './codex-protocol.js';
-import { type AgentAdapter, type AgentSession, type EffortOption, type SessionSpec } from './types.js';
+import { type AgentAdapter, type AgentQuestion, type AgentSession, type EffortOption, type SessionSpec } from './types.js';
 export interface CodexAdapterDeps {
     /** Injected in tests to drive a scripted app-server. */
     spawnClient?: (options: {
@@ -43,8 +43,23 @@ export interface CodexAdapterDeps {
  * message also talks about tokens or signing in — and never when it names MCP.
  */
 export declare function isAuthError(message: string): boolean;
-/** The dashboard shows "label — description"; the wire wants the label. */
-export declare function stripOptionHint(text: string): string;
+/**
+ * The card shows "label — description"; the wire wants the bare label.
+ *
+ * Only strips when the text really is one of the offered options. The old
+ * version cut every answer at the first « — », which quietly destroyed any
+ * free-text answer containing a dash — "MariaDB — we already pay for it"
+ * reached the agent as "MariaDB".
+ */
+export declare function stripOptionHint(text: string, labels?: string[]): string;
+/**
+ * One `item/tool/requestUserInput` elicitation → the normalized question list.
+ *
+ * Codex sends the whole list; before session 12 we kept `questions[0]` and
+ * dropped the rest. `isOther` is a question-level flag meaning "free text is
+ * acceptable here", and `isSecret` means the answer must not be echoed.
+ */
+export declare function parseElicitation(params: Record<string, unknown>): AgentQuestion[];
 /**
  * `supportedReasoningEfforts` from `model/list`: a list of
  * `{reasoningEffort, description}`. Codex 0.145 ships six levels on the Sol

package/dist/adapters/codex.js

@@ -6,6 +6,7 @@ import { repairCodexAuth } from './codex-home.js';
 import { AppServerClient, asRecord, num, str } from './codex-protocol.js';
 import { truncate } from './claude.js';
 import { AGENT_MODES, } from './types.js';
+import { answerSummary, invalidationMessage, mirrorOptions, newAskId, MAX_OPTIONS, MAX_QUESTIONS, OPTION_TEXT_LIMIT, QUESTION_TEXT_LIMIT, } from './questions.js';
 // Codex adapter over `codex app-server` (stage C). The normalized AgentEvent
 // contract is unchanged, so the dashboard renders Codex sessions with the same
 // components it already uses for Claude.
@@ -62,11 +63,15 @@ const SYSTEM_APPEND = [
     'You are running inside a DevBridge dev session, controlled from the DevBridge dashboard.',
     'Rules:',
     '- Work ONLY inside the current working directory (a dedicated git worktree on a session branch).',
-    '- Commit your work in the current branch with clear messages. NEVER push to main/master and never force-push.',
+    '- Commit your work in the current branch with clear messages. You cannot push: `git push` is blocked. A human presses «Push» and «Apply» in DevBridge when the branch is ready.',
     '- If DevBridge MCP tools are available and the task mentions tickets: fetch the ticket first, set its status to IN_PROGRESS when you start and READY_FOR_REVIEW when your implementation is complete, and leave a short summary comment.',
     '- The user is not in a terminal: if you need a decision, use your question tool or ask in plain text and end your turn.',
     '- Never print secrets (tokens, API keys, private keys) in your output.',
 ].join('\n');
+/** DevBridge's own rules, then whatever this workspace adds (session 13). */
+function composeSystemAppend(workspaceContext) {
+    return workspaceContext ? `${SYSTEM_APPEND}\n\n${workspaceContext}` : SYSTEM_APPEND;
+}
 // Allowlist, not denylist: whatever secrets live in the daemon's environment
 // must not reach the agent process. OPENAI_API_KEY is absent by design — it
 // would override the subscription login the same way ANTHROPIC_API_KEY does for
@@ -113,8 +118,6 @@ const APPROVAL_METHODS = new Set([
     'item/permissions/requestApproval',
     'mcpServer/elicitation/request',
 ]);
-/** An unanswered agent question must not hold the turn forever. */
-const QUESTION_TIMEOUT_MS = 30 * 60_000;
 class CodexSession {
     spec;
     home;
@@ -127,7 +130,8 @@ class CodexSession {
     queuedInput = [];
     /** Null when the home was injected — an injected home is the whole truth. */
     repairHome;
-    question = null;
+    /** Open elicitations, oldest first — Codex may have several in flight. */
+    questions = new Map();
     threadId = null;
     threadModel = null;
     activeTurnId = null;
@@ -340,7 +344,7 @@ class CodexSession {
             cwd: this.spec.cwd,
             approvalPolicy: policy.approvalPolicy,
             sandbox: policy.sandbox,
-            developerInstructions: SYSTEM_APPEND,
+            developerInstructions: composeSystemAppend(this.spec.workspaceContext),
             ...(this.model ? { model: this.model } : {}),
             ...(this.spec.mcp ? { config: this.mcpOverlay() } : {}),
         };
@@ -395,15 +399,20 @@ class CodexSession {
             ...(this.effort ? { effort: this.effort } : {}),
         };
         // Collaboration mode is turn-scoped but sticky, and its `settings` REPLACE
-        // the thread's developer instructions — so only send it on a real change,
-        // and restore our own rules when leaving plan mode.
+        // the thread's developer instructions — so only send it on a real change.
+        //
+        // Session 13: they are sent for plan mode too. Passing `null` there did not
+        // mean «keep what the thread had», it meant «no developer instructions at
+        // all» — so the one mode a user picks when they want the agent to think
+        // before acting was the one mode where DevBridge's rules, the branch it is
+        // on and the project's own CLAUDE.md never reached it.
         if (this.lastCollabMode !== wantCollab) {
             params['collaborationMode'] = {
                 mode: wantCollab,
                 settings: {
                     model: this.model ?? this.threadModel ?? 'gpt-5.5',
                     reasoning_effort: null,
-                    developer_instructions: wantCollab === 'plan' ? null : SYSTEM_APPEND,
+                    developer_instructions: composeSystemAppend(this.spec.workspaceContext),
                 },
             };
             this.lastCollabMode = wantCollab;
@@ -434,9 +443,20 @@ class CodexSession {
             return;
         }
         // A parked elicitation takes priority: the agent is blocked on it, and
-        // starting a turn would deadlock behind the open request.
-        if (this.question) {
-            this.answerQuestion(text);
+        // starting a turn would deadlock behind the open request. Typing is a
+        // legitimate way to answer (Telegram has no card), so the text becomes the
+        // answer to the oldest open ask.
+        const oldest = this.questions.values().next().value;
+        if (oldest) {
+            this.answerQuestion({
+                askId: oldest.askId,
+                action: 'answer',
+                answers: oldest.questions.map((question) => ({
+                    questionId: question.id,
+                    values: [],
+                    custom: text,
+                })),
+            });
             return;
         }
         // Answering a plan card by typing instead of clicking is normal ("do it
@@ -509,6 +529,17 @@ class CodexSession {
         // we just dropped an unsupported pick), so the UI dial stays truthful.
         this.refreshCapabilities();
     }
+    /**
+     * Session 15: the project's trust level and auto-commit switch, changed while
+     * this session runs. `this.spec` is what `evaluateToolUse` reads on every
+     * tool call, so the next one already sees it.
+     */
+    setWorkspacePolicy(policy) {
+        if (policy.trustMode !== undefined)
+            this.spec.trustMode = policy.trustMode;
+        if (policy.agentAutoCommit !== undefined)
+            this.spec.agentAutoCommit = policy.agentAutoCommit;
+    }
     async setEffort(effort) {
         if (effort)
             this.effort = effort;
@@ -536,20 +567,37 @@ class CodexSession {
             log.warn('codex: interrupt failed', { error: describe(error) });
         }
     }
-    stop() {
+    stop(reason = 'session_stopped') {
         if (this.stopped)
             return;
         this.stopped = true;
-        // Release anything the agent is blocked on so the child can exit cleanly.
+        // Release anything the agent is blocked on so the child can exit cleanly —
+        // and say in the feed that the runner did it, not the user. A pending card
+        // used to gutter out looking like a human decision.
         for (const [requestId, pending] of [...this.approvals]) {
             this.approvals.delete(requestId);
+            this.emit({
+                type: 'permission_resolved',
+                requestId,
+                allow: false,
+                source: 'runner',
+                reason: invalidationMessage(reason),
+            });
             this.client.respond(pending.rpcId, { decision: 'cancel' });
         }
-        if (this.question) {
-            if (this.question.timer)
-                clearTimeout(this.question.timer);
-            this.client.respond(this.question.rpcId, { answers: {} });
-            this.question = null;
+        for (const pending of [...this.questions.values()]) {
+            this.questions.delete(pending.askId);
+            this.emit({
+                type: 'question_resolved',
+                askId: pending.askId,
+                outcome: 'invalidated',
+                source: 'runner',
+                reason,
+            });
+            // Empty answers only because the process is being killed on the next
+            // line — the RPC has to be released or the child never exits. This is a
+            // teardown, not the 30-minute auto-answer it replaced.
+            this.client.respond(pending.rpcId, { answers: {} });
         }
         this.client.kill();
     }
@@ -575,6 +623,9 @@ class CodexSession {
             ? { decision: 'ask', reason: 'details unavailable' }
             : evaluateToolUse(enriched.policyTool, enriched.policyInput, {
                 trustMode: this.spec.trustMode,
+                ...(this.spec.agentAutoCommit === undefined
+                    ? {}
+                    : { agentAutoCommit: this.spec.agentAutoCommit }),
                 worktreePath: this.spec.cwd,
             });
         if (verdict.decision === 'allow') {
@@ -728,61 +779,99 @@ class CodexSession {
         this.client.respond(pending.rpcId, { decision: allow ? 'accept' : 'decline' });
     }
     onQuestion(request) {
-        const questions = Array.isArray(request.params['questions']) ? request.params['questions'] : [];
-        const first = asRecord(questions[0]);
-        const questionId = str(first['id']);
-        const text = str(first['question']) ?? str(first['header']);
-        if (!questionId || !text) {
+        const questions = parseElicitation(request.params);
+        if (questions.length === 0) {
             // Nothing renderable — answer empty so the turn continues instead of
-            // blocking forever.
+            // blocking forever on a card nobody can see.
             this.client.respond(request.id, { answers: {} });
             return;
         }
-        const rawOptions = Array.isArray(first['options']) ? first['options'] : [];
-        const options = rawOptions
-            .map((option) => {
-            const row = asRecord(option);
-            const label = str(row['label']);
-            if (!label)
-                return null;
-            const description = str(row['description']);
-            return truncate(description ? `${label} — ${description}` : label, 300);
-        })
-            .filter((option) => Boolean(option))
-            .slice(0, 8);
-        // There is no server-side timeout for elicitations: an unanswered question
-        // blocks the turn forever and the only way out is Stop (QA-100 MINOR-4).
-        const timer = setTimeout(() => {
-            if (this.question?.rpcId !== request.id)
-                return;
-            this.question = null;
-            this.client.respond(request.id, { answers: {} });
-            this.notice('warn', 'The agent question went unanswered for 30 minutes — it was skipped.');
-        }, QUESTION_TIMEOUT_MS);
-        timer.unref();
-        this.question = { rpcId: request.id, questionId, timer };
+        const askId = newAskId();
+        this.questions.set(askId, { askId, rpcId: request.id, questions });
         this.emit({
             type: 'question',
-            text: truncate(text, 2_000),
-            ...(options.length ? { options } : {}),
+            askId,
+            questions,
+            // Mirror fields for an API/dashboard that has not been redeployed yet.
+            text: questions[0]?.text ?? '',
+            ...(mirrorOptions(questions).length ? { options: mirrorOptions(questions) } : {}),
         });
     }
     /**
-     * The user's next message answers the open elicitation. The wire wants the
-     * option label verbatim, and free text is legal whenever `isOther` is set —
-     * so we forward whatever was typed, and the option list the dashboard shows
-     * is made of those same labels.
+     * Answer (or talk past) an open elicitation.
+     *
+     * Codex has no "deny with a message" for elicitations — responding IS the
+     * only way to unblock the turn — so «discuss» reaches the agent as free-text
+     * answers on the questions that accept them. The wire wants an option label
+     * verbatim, and free text is legal whenever the question sets `isOther`.
      */
-    answerQuestion(text) {
-        const pending = this.question;
+    answerQuestion(reply) {
+        const pending = this.questions.get(reply.askId);
+        if (!pending) {
+            log.warn('codex: answer for a question that is no longer open', { askId: reply.askId });
+            return false;
+        }
+        this.questions.delete(reply.askId);
+        const byId = new Map(pending.questions.map((question) => [question.id, question]));
+        const answers = reply.action === 'discuss'
+            ? pending.questions.map((question) => ({
+                questionId: question.id,
+                values: [],
+                custom: reply.text ?? '',
+            }))
+            : (reply.answers ?? []).filter((answer) => byId.has(answer.questionId));
+        const wire = {};
+        for (const answer of answers) {
+            const question = byId.get(answer.questionId);
+            if (!question)
+                continue;
+            const labels = question.options.map((option) => option.label);
+            const values = [
+                // A picked option travels as its own label, never as the
+                // «label — description» line the card renders.
+                ...answer.values.map((value) => stripOptionHint(value, labels)),
+                ...(answer.custom?.trim() ? [stripOptionHint(answer.custom.trim(), labels)] : []),
+            ].filter(Boolean);
+            if (values.length === 0)
+                continue;
+            wire[question.id] = { answers: values };
+        }
+        // Never echo a secret answer into the feed — the event payload is stored
+        // for the retention window, and a token has no business there.
+        const secret = pending.questions.some((question) => question.secret);
+        this.emit({
+            type: 'question_resolved',
+            askId: reply.askId,
+            outcome: reply.action === 'discuss' ? 'discussed' : 'answered',
+            source: 'user',
+            ...(secret ? {} : { answers, summary: answerSummary(answers) }),
+            ...(secret ? { summary: '••••••' } : {}),
+        });
+        this.client.respond(pending.rpcId, { answers: wire });
+        return true;
+    }
+    cancelQuestions(reason) {
+        for (const pending of [...this.questions.values()]) {
+            this.invalidateQuestion(pending.askId, reason);
+            // Unlike a withdrawal seen from codex's side, this one has to release the
+            // rpc ourselves: an elicitation left parked keeps blocking, and `send()`
+            // would then feed the user's NEXT message into a question whose turn is
+            // already gone (QA-106 m7).
+            this.client.respond(pending.rpcId, { answers: {} });
+        }
+    }
+    /** Withdraw an open question with a reason, without answering for the user. */
+    invalidateQuestion(askId, reason) {
+        const pending = this.questions.get(askId);
         if (!pending)
             return;
-        if (pending.timer)
-            clearTimeout(pending.timer);
-        this.question = null;
-        const answer = stripOptionHint(text);
-        this.client.respond(pending.rpcId, {
-            answers: { [pending.questionId]: { answers: [answer] } },
+        this.questions.delete(askId);
+        this.emit({
+            type: 'question_resolved',
+            askId,
+            outcome: 'invalidated',
+            source: 'runner',
+            reason,
         });
     }
     // ─── Notifications ─────────────────────────────────────────────────
@@ -841,6 +930,13 @@ class CodexSession {
                 // unknown outcome would put a false approval in the audit trail
                 // (QA-100 MINOR-3).
                 const resolved = String(params['requestId'] ?? '');
+                // A question resolved elsewhere is withdrawn, not answered — the card
+                // must stop being clickable and say why.
+                for (const pending of [...this.questions.values()]) {
+                    if (String(pending.rpcId) === resolved) {
+                        this.invalidateQuestion(pending.askId, 'agent_cancelled');
+                    }
+                }
                 if (this.approvals.delete(resolved)) {
                     const decision = str(params['decision']) ?? str(asRecord(params['response'])['decision']);
                     const allow = decision === 'accept' || decision === 'approved';
@@ -1333,10 +1429,73 @@ function basename(file) {
 function toolNameFromMessage(message) {
     return message?.match(/tool\s+"([^"]+)"/)?.[1];
 }
-/** The dashboard shows "label — description"; the wire wants the label. */
-export function stripOptionHint(text) {
-    const separator = text.indexOf(' — ');
-    return separator === -1 ? text : text.slice(0, separator);
+/**
+ * The card shows "label — description"; the wire wants the bare label.
+ *
+ * Only strips when the text really is one of the offered options. The old
+ * version cut every answer at the first « — », which quietly destroyed any
+ * free-text answer containing a dash — "MariaDB — we already pay for it"
+ * reached the agent as "MariaDB".
+ */
+export function stripOptionHint(text, labels = []) {
+    const trimmed = text.trim();
+    for (const label of labels) {
+        if (trimmed === label)
+            return label;
+        if (trimmed.startsWith(`${label} — `))
+            return label;
+    }
+    return trimmed;
+}
+/**
+ * One `item/tool/requestUserInput` elicitation → the normalized question list.
+ *
+ * Codex sends the whole list; before session 12 we kept `questions[0]` and
+ * dropped the rest. `isOther` is a question-level flag meaning "free text is
+ * acceptable here", and `isSecret` means the answer must not be echoed.
+ */
+export function parseElicitation(params) {
+    const raw = Array.isArray(params['questions']) ? params['questions'] : [];
+    const questions = [];
+    for (const entry of raw.slice(0, MAX_QUESTIONS)) {
+        const row = asRecord(entry);
+        const id = str(row['id']);
+        const text = str(row['question']) ?? str(row['header']);
+        if (!id || !text)
+            continue;
+        const header = str(row['header']);
+        const rawOptions = Array.isArray(row['options']) ? row['options'] : [];
+        const options = rawOptions
+            .map((option) => {
+            const optionRow = asRecord(option);
+            const label = str(optionRow['label']);
+            if (!label)
+                return null;
+            const description = str(optionRow['description']);
+            return {
+                label: truncate(label, OPTION_TEXT_LIMIT),
+                ...(description ? { description: truncate(description, OPTION_TEXT_LIMIT) } : {}),
+            };
+        })
+            .filter((option) => option !== null)
+            .slice(0, MAX_OPTIONS);
+        questions.push({
+            id,
+            text: truncate(text, QUESTION_TEXT_LIMIT),
+            ...(header ? { header: header.slice(0, 24) } : {}),
+            multiSelect: row['multiSelect'] === true,
+            // Free text is offered only when codex says it is acceptable, or when
+            // there is nothing to pick from at all. The flag sits on the question in
+            // 0.135.0; an option-level one is honoured too rather than silently
+            // taking the free-text box away if a later build moves it.
+            allowsCustom: row['isOther'] === true ||
+                rawOptions.some((option) => asRecord(option)['isOther'] === true) ||
+                options.length === 0,
+            ...(row['isSecret'] === true ? { secret: true } : {}),
+            options,
+        });
+    }
+    return questions;
 }
 /**
  * `supportedReasoningEfforts` from `model/list`: a list of

package/dist/adapters/questions.d.ts

@@ -0,0 +1,42 @@
+import type { AgentQuestion, AgentQuestionAnswer, QuestionInvalidationReason } from './types.js';
+/** Longest question text we put on the wire (the API caps a payload at 128KB). */
+export declare const QUESTION_TEXT_LIMIT = 2000;
+/** Longest option label/description; the card truncates visually beyond that. */
+export declare const OPTION_TEXT_LIMIT = 300;
+/** Options we keep per question — a picker with more is unusable anyway. */
+export declare const MAX_OPTIONS = 8;
+/** Questions we keep per ask (Claude's own tool allows at most 4). */
+export declare const MAX_QUESTIONS = 4;
+/**
+ * Local copy of the adapters' `truncate`, on purpose: importing it from
+ * `claude.ts` would make this module and the Claude adapter import each other,
+ * and a cycle is not worth six lines.
+ */
+export declare function clip(text: string, limit: number): string;
+/**
+ * Identity of one ask.
+ *
+ * Deliberately random and NOT derived from the SDK request id or the Codex rpc
+ * id: those restart from scratch in a new agent process, so a card left open in
+ * a browser tab from a previous life of the session would answer a live
+ * question that has nothing to do with it (session-12 plan §4.3).
+ */
+export declare function newAskId(): string;
+/** The pre-session-12 `options: string[]` shape — «label — description». */
+export declare function mirrorOptions(questions: AgentQuestion[]): string[];
+/** What one answer says, as a single line: «Postgres», «Auth, Search». */
+export declare function answerValue(answer: AgentQuestionAnswer): string;
+/** One short line for the resolved card: «Postgres · Auth, Search». */
+export declare function answerSummary(answers: AgentQuestionAnswer[]): string;
+/**
+ * The «discuss instead» exit.
+ *
+ * Goes back as a tool DENIAL carrying the user's words. Live-verified against
+ * the bundled CLI (session-12 §3): a deny with a message does not end the turn
+ * — the text arrives as the tool result and the agent keeps working — while a
+ * deny with no message, or `interrupt: true`, does end it.
+ */
+export declare function discussMessage(questions: AgentQuestion[], text: string): string;
+/** The question was taken away from the user — say why, never fake an answer. */
+export declare function invalidationMessage(reason: QuestionInvalidationReason): string;
+//# sourceMappingURL=questions.d.ts.map

package/dist/adapters/questions.js

@@ -0,0 +1,86 @@
+import { randomBytes } from 'node:crypto';
+// Everything both adapters need to speak the session-12 question contract in
+// one voice: the id that identifies an ask, the mirror fields older clients
+// still read, and the three sentences the agent gets back.
+/** Longest question text we put on the wire (the API caps a payload at 128KB). */
+export const QUESTION_TEXT_LIMIT = 2_000;
+/** Longest option label/description; the card truncates visually beyond that. */
+export const OPTION_TEXT_LIMIT = 300;
+/** Options we keep per question — a picker with more is unusable anyway. */
+export const MAX_OPTIONS = 8;
+/** Questions we keep per ask (Claude's own tool allows at most 4). */
+export const MAX_QUESTIONS = 4;
+/**
+ * Local copy of the adapters' `truncate`, on purpose: importing it from
+ * `claude.ts` would make this module and the Claude adapter import each other,
+ * and a cycle is not worth six lines.
+ */
+export function clip(text, limit) {
+    return text.length > limit
+        ? `${text.slice(0, limit)}\n…[truncated ${text.length - limit} chars]`
+        : text;
+}
+/**
+ * Identity of one ask.
+ *
+ * Deliberately random and NOT derived from the SDK request id or the Codex rpc
+ * id: those restart from scratch in a new agent process, so a card left open in
+ * a browser tab from a previous life of the session would answer a live
+ * question that has nothing to do with it (session-12 plan §4.3).
+ */
+export function newAskId() {
+    return `q_${randomBytes(6).toString('hex')}`;
+}
+/** The pre-session-12 `options: string[]` shape — «label — description». */
+export function mirrorOptions(questions) {
+    const first = questions[0];
+    if (!first)
+        return [];
+    return first.options
+        .map((option) => clip(option.description ? `${option.label} — ${option.description}` : option.label, OPTION_TEXT_LIMIT))
+        .slice(0, MAX_OPTIONS);
+}
+/** What one answer says, as a single line: «Postgres», «Auth, Search». */
+export function answerValue(answer) {
+    const parts = [...answer.values.map((value) => value.trim()).filter(Boolean)];
+    const custom = answer.custom?.trim();
+    if (custom)
+        parts.push(custom);
+    return parts.join(', ');
+}
+/** One short line for the resolved card: «Postgres · Auth, Search». */
+export function answerSummary(answers) {
+    return clip(answers.map(answerValue).filter(Boolean).join(' · '), OPTION_TEXT_LIMIT);
+}
+/**
+ * The «discuss instead» exit.
+ *
+ * Goes back as a tool DENIAL carrying the user's words. Live-verified against
+ * the bundled CLI (session-12 §3): a deny with a message does not end the turn
+ * — the text arrives as the tool result and the agent keeps working — while a
+ * deny with no message, or `interrupt: true`, does end it.
+ */
+export function discussMessage(questions, text) {
+    const asked = questions.map((question) => `"${question.text}"`).join('; ');
+    return clip([
+        'The user chose to reply in their own words instead of picking an option.',
+        `They wrote: ${text.trim() || '(nothing)'}`,
+        asked ? `Still unanswered: ${asked}.` : '',
+        'Continue from what they wrote. Do not answer these questions on their behalf — ask again if you still need a decision.',
+    ]
+        .filter(Boolean)
+        .join('\n'), 8_000);
+}
+const INVALIDATION_PHRASES = {
+    session_stopped: 'the session was stopped',
+    session_parked: 'the runner parked this session to free a slot for another one',
+    runner_restarted: 'the runner restarted',
+    turn_aborted: 'the turn was interrupted',
+    agent_cancelled: 'the agent withdrew it',
+    budget_spent: 'the session ran out of its allowed working time',
+};
+/** The question was taken away from the user — say why, never fake an answer. */
+export function invalidationMessage(reason) {
+    return `The question was withdrawn before the user answered — ${INVALIDATION_PHRASES[reason]}. Do not assume an answer.`;
+}
+//# sourceMappingURL=questions.js.map