@cmgmyr/hive 1.10.1 → 1.11.1

package/dist/leadState.js

@@ -1,5 +1,7 @@
+import { liveBackgroundTasks } from "./backgroundTasks.js";
 import { db } from "./db.js";
 import { FIRST_MESSAGE_SHA_ENV, firstMessageDigest } from "./firstMessage.js";
+import { postponeGrace, readActiveHandoff } from "./leadHandoffState.js";
 export function readLeadTurnState(agentId) {
     return db.prepare("SELECT * FROM lead_turn_state WHERE agent_id = ?").get(agentId) ?? null;
 }
@@ -9,7 +11,23 @@ export function leadSessionEnded(row, ownership) {
     const turn = readLeadTurnState(row.id);
     return turn?.last_event === "session_end" && turn.pane_pid === row.pane_pid ? { ended_at: turn.changed_at } : null;
 }
-function isHiveFirstMessage(payload) {
+// The hive-authored prompt shapes conversationHoldsWake excludes, as SQL over an agent_state_log
+// payload column. isHumanPrompt below is its JS twin; a parity test keeps them in step.
+export function humanPromptSql(col) {
+    const p = `CASE WHEN json_valid(${col}) THEN COALESCE(json_extract(${col}, '$.prompt'), ${col}) ELSE ${col} END`;
+    return (`${p} NOT LIKE '%[hive wake #%' AND ${p} NOT LIKE '[hive:%' AND ${p} NOT LIKE '<task-notification>%' ` +
+        `AND ${p} NOT LIKE '<cross-session-message from="%" from-name="hive">' || char(10) || '[hive:worker %] [message #%,%' || char(10) || '</cross-session-message>%'`);
+}
+// Includes SQLite LIKE's ASCII case-insensitivity.
+export function isHumanPrompt(prompt) {
+    const p = prompt.toLowerCase();
+    if (p.includes("[hive wake #") || p.startsWith("[hive:") || p.startsWith("<task-notification>"))
+        return false;
+    return !/^<cross-session-message from="[\s\S]*" from-name="hive">\n\[hive:worker [\s\S]*\] \[message #[\s\S]*,[\s\S]*\n<\/cross-session-message>/.test(p);
+}
+// The agent_state_log state label on hive's own first message to a lead; conversationHoldsWake skips it.
+export const FIRST_MESSAGE_LOG_STATE = "first_message";
+export function isHiveFirstMessage(payload) {
     if (typeof payload.prompt !== "string")
         return false;
     const prompt = payload.prompt.trim();
@@ -41,24 +59,86 @@ export function nextLeadTurn(cur, panePid, event, payload, subagentsLive) {
             return null;
     }
 }
-const applyInTransaction = db.transaction((agentId, panePid, event, payload, subagentsLive) => {
-    const cur = readLeadTurnState(agentId);
-    const next = nextLeadTurn(cur, panePid, event, payload, subagentsLive);
-    if (next === null)
+export function readLeadSafetySnapshot(agentId) {
+    return (db.prepare("SELECT * FROM lead_turn_state WHERE agent_id = ?").get(agentId) ?? null);
+}
+function applySnapshot(agentId, panePid, event, payload) {
+    const row = readLeadSafetySnapshot(agentId);
+    const sessionId = typeof payload.session_id === "string" ? payload.session_id : "";
+    if (row === null || sessionId === "" || row.pane_pid !== panePid || row.session_id !== sessionId)
         return;
-    if (cur !== null &&
-        cur.pane_pid === next.pane_pid &&
-        cur.session_id === next.session_id &&
-        cur.state === next.state &&
-        cur.idle_seq === next.idle_seq &&
-        (event !== "session_end" || cur.last_event === "session_end")) {
+    const fresh = row.snapshot_pane_pid !== panePid || row.snapshot_session_id !== sessionId;
+    const snap = {
+        prompt_seq: fresh ? 0 : row.prompt_seq,
+        human_prompt_seq: fresh ? 0 : row.human_prompt_seq,
+        human_prompt_at: fresh ? null : row.human_prompt_at,
+        transcript_path: fresh ? "" : row.transcript_path,
+        stop_prompt_seq: fresh ? null : row.stop_prompt_seq,
+        stop_background: fresh ? null : row.stop_background,
+        stop_at: fresh ? null : row.stop_at,
+    };
+    if (typeof payload.transcript_path === "string" && payload.transcript_path !== "") {
+        snap.transcript_path = payload.transcript_path;
+    }
+    const now = db.prepare("SELECT strftime('%Y-%m-%d %H:%M:%f', 'now') AS now").get().now;
+    switch (event) {
+        case "prompt":
+            snap.prompt_seq += 1;
+            if (typeof payload.prompt === "string" && !isHiveFirstMessage(payload) && isHumanPrompt(payload.prompt.trim())) {
+                snap.human_prompt_seq += 1;
+                snap.human_prompt_at = now;
+                // A human prompt during grace postpones that attempt at once; the grace owner sees it too.
+                const active = readActiveHandoff(agentId);
+                if (active?.state === "grace" && active.predecessor_session_id === sessionId) {
+                    postponeGrace(active, { predecessor_session_id: sessionId }, "a human prompt arrived during grace", true);
+                }
+            }
+            break;
+        case "stop":
+            snap.stop_prompt_seq = snap.prompt_seq;
+            snap.stop_at = now;
+            // No background_tasks in the payload is unknown evidence, never an empty list.
+            snap.stop_background = payload.background_tasks === undefined
+                ? null
+                : JSON.stringify(liveBackgroundTasks(payload.background_tasks));
+            break;
+    }
+    db.prepare(`UPDATE lead_turn_state SET snapshot_pane_pid = ?, snapshot_session_id = ?, prompt_seq = ?, human_prompt_seq = ?,
+       human_prompt_at = ?, transcript_path = ?, stop_prompt_seq = ?, stop_background = ?, stop_at = ?
+     WHERE agent_id = ?`).run(panePid, sessionId, snap.prompt_seq, snap.human_prompt_seq, snap.human_prompt_at, snap.transcript_path, snap.stop_prompt_seq, snap.stop_background, snap.stop_at, agentId);
+}
+// The states after a respawn claim, in which the predecessor's session is no longer the lead.
+export const HANDED_OFF_STATES_SQL = "('respawning', 'started', 'completed', 'ambiguous')";
+// A predecessor-session hook is fenced from the respawn claim until the handoff completes or fails;
+// the pane pid cannot tell a dying predecessor from an in-pane /resume, so the row's state decides.
+export function predecessorFence(agentId, sessionId) {
+    if (typeof sessionId !== "string" || sessionId === "")
+        return false;
+    return (db
+        .prepare(`SELECT 1 AS hit FROM lead_handoffs WHERE lead_agent_id = ? AND predecessor_session_id = ?
+           AND state IN ('respawning', 'started', 'ambiguous')`)
+        .get(agentId, sessionId) !== undefined);
+}
+const applyInTransaction = db.transaction((agentId, panePid, event, payload, subagentsLive, fenced) => {
+    if (fenced)
         return;
+    const cur = readLeadTurnState(agentId);
+    const next = nextLeadTurn(cur, panePid, event, payload, subagentsLive);
+    const unchanged = next === null ||
+        (cur !== null &&
+            cur.pane_pid === next.pane_pid &&
+            cur.session_id === next.session_id &&
+            cur.state === next.state &&
+            cur.idle_seq === next.idle_seq &&
+            (event !== "session_end" || cur.last_event === "session_end"));
+    if (!unchanged) {
+        db.prepare(`INSERT INTO lead_turn_state (agent_id, pane_pid, session_id, state, idle_seq, last_event, changed_at)
+         VALUES (?, ?, ?, ?, ?, ?, strftime('%Y-%m-%d %H:%M:%f', 'now'))
+         ON CONFLICT(agent_id) DO UPDATE SET pane_pid = excluded.pane_pid, session_id = excluded.session_id,
+           state = excluded.state, idle_seq = excluded.idle_seq, last_event = excluded.last_event,
+           changed_at = excluded.changed_at`).run(agentId, next.pane_pid, next.session_id, next.state, next.idle_seq, event);
     }
-    db.prepare(`INSERT INTO lead_turn_state (agent_id, pane_pid, session_id, state, idle_seq, last_event, changed_at)
-       VALUES (?, ?, ?, ?, ?, ?, strftime('%Y-%m-%d %H:%M:%f', 'now'))
-       ON CONFLICT(agent_id) DO UPDATE SET pane_pid = excluded.pane_pid, session_id = excluded.session_id,
-         state = excluded.state, idle_seq = excluded.idle_seq, last_event = excluded.last_event,
-         changed_at = excluded.changed_at`).run(agentId, next.pane_pid, next.session_id, next.state, next.idle_seq, event);
+    applySnapshot(agentId, panePid, event, payload);
 });
 export function applyLeadHook(actorId, event, payload, subagentsLive) {
     const lead = db
@@ -66,5 +146,6 @@ export function applyLeadHook(actorId, event, payload, subagentsLive) {
         .get(actorId);
     if (!lead)
         return;
-    applyInTransaction.immediate(lead.id, lead.pane_pid, event, payload, subagentsLive);
+    const fenced = predecessorFence(lead.id, payload.session_id);
+    applyInTransaction.immediate(lead.id, lead.pane_pid, event, payload, subagentsLive, fenced);
 }

package/dist/portfolio.js

@@ -3,10 +3,12 @@ import { listProjects } from "./context.js";
 import { existsSync } from "node:fs";
 import { parseTags } from "./result.js";
 import { OPEN_BLOCKERS_SQL } from "./tools/todos.js";
+import { pendingQuestionCount } from "./questions.js";
 import { leadSessionEnded, readLeadTurnState } from "./leadState.js";
 import { liveTargets, ownershipLiveness, rowOwnership } from "./tmux.js";
 export const PORTFOLIO_REASONS = [
     "needs_human",
+    "questions_pending",
     "dead_lead_pane",
     "missing_root_with_work",
     "worker_needs_input",
@@ -135,9 +137,12 @@ function projectRow(project, now, snapshot) {
     const staleClock = lastActivity(project.id, false);
     const staleBefore = shiftedClock(now, STALE_IN_PROGRESS);
     const activeTodos = todos.open + todos.in_progress;
+    const questionsPending = pendingQuestionCount(project.id);
     const found = new Set();
     if (tagged.length > 0)
         found.add("needs_human");
+    if (questionsPending > 0)
+        found.add("questions_pending");
     if ((lead.state === "dead_pane" || lead.state === "dormant") && (todos.in_progress > 0 || wakeCounts.pending > 0))
         found.add("dead_lead_pane");
     if (!rootExists && (activeTodos > 0 || wakeCounts.pending > 0))
@@ -172,7 +177,7 @@ function projectRow(project, now, snapshot) {
         lane = "stuck";
     else if (movingSignal)
         lane = "moving";
-    else if (found.has("needs_human"))
+    else if (found.has("needs_human") || found.has("questions_pending"))
         lane = "waiting_on_you";
     else if (TODO_GRAPH.some((r) => found.has(r)))
         lane = "stuck";
@@ -191,6 +196,7 @@ function projectRow(project, now, snapshot) {
         workers,
         todos,
         needs_human: tagged.length,
+        questions_pending: questionsPending,
         needs_human_items: tagged.slice(0, NEEDS_HUMAN_ITEM_CAP).map((t) => ({
             todo_id: t.id,
             title: t.title,

package/dist/projectRemove.js

@@ -10,6 +10,7 @@ export const PROJECT_OWNER_TABLES = [
     "agents",
     "wakes",
     "command_trust",
+    "questions",
 ];
 const COUNTED_TABLES = [
     ...PROJECT_OWNER_TABLES.map((t) => [t, `SELECT COUNT(*) AS n FROM ${t} WHERE project_id = ?`]),

package/dist/projectYml.js

@@ -180,7 +180,14 @@ function applyLayer(root, path, source, config, sources, warnings) {
         }
         else if (isMapping(value) && typeof value.warn === "number" && Number.isInteger(value.warn) && value.warn > 0 &&
             typeof value.stop === "number" && Number.isInteger(value.stop) && value.stop > value.warn) {
-            config.lead_turn_budget = { warn: value.warn, stop: value.stop };
+            const budget = { warn: value.warn, stop: value.stop };
+            if (value.auto_handoff !== undefined) {
+                if (typeof value.auto_handoff === "boolean")
+                    budget.auto_handoff = value.auto_handoff;
+                else
+                    warn(`lead_turn_budget.auto_handoff must be true or false; ignoring "${String(value.auto_handoff)}", so automatic handoff stays off.`);
+            }
+            config.lead_turn_budget = budget;
             sources.lead_turn_budget = source;
         }
         else {

package/dist/queenAudit.js

@@ -13,6 +13,11 @@ function removalSummary(r) {
     const counts = Object.entries((r.counts ?? {})).map(([t, n]) => `${t} ${n}`);
     return `removed project "${r.name}"${counts.length > 0 ? ` with ${counts.join(", ")}` : ""}`;
 }
+function insertQueenAuditRow(operation, targetProjectId, identity, resourceType, resourceId, summary, outcome = "confirmed", problem = "") {
+    db.prepare(`INSERT INTO queen_audit
+       (actor_id, home_project_id, target_project_id, operation, resource_type, resource_id, summary, outcome, problem)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(identity.actor_id, identity.home_project_id, targetProjectId, operation, resourceType, resourceId, summary, outcome, problem);
+}
 export const QUEEN_AUDIT_OPERATIONS = {
     todo_create: {
         mode: "database",
@@ -78,8 +83,15 @@ function insertAudit(operation, targetProjectId, args, receipt, identity) {
         return;
     const text = flatten(spec.summary(args, receipt));
     const summary = text.length <= QUEEN_AUDIT_SUMMARY_MAX ? text : cutToUnitBudget(text, QUEEN_AUDIT_SUMMARY_MAX - 1) + "…";
-    db.prepare(`INSERT INTO queen_audit (actor_id, home_project_id, target_project_id, operation, resource_type, resource_id, summary)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(identity.actor_id, identity.home_project_id, targetProjectId, operation, touched.type, touched.id, summary);
+    insertQueenAuditRow(operation, targetProjectId, identity, touched.type, touched.id, summary);
+}
+export function recordQueenRefusal(operation, targetProjectId, problem, identity) {
+    const text = flatten(problem);
+    const summaryText = `refused: ${text}`;
+    const summary = summaryText.length <= QUEEN_AUDIT_SUMMARY_MAX
+        ? summaryText
+        : cutToUnitBudget(summaryText, QUEEN_AUDIT_SUMMARY_MAX - 1) + "…";
+    insertQueenAuditRow(operation, targetProjectId, identity, "project", targetProjectId, summary, "refused", text);
 }
 export function commitQueenStateWrite(operation, targetProjectId, args, mutate) {
     const identity = captureQueenWriteIdentity(targetProjectId);

package/dist/queenDashboard.js

@@ -84,6 +84,7 @@ const LANE_COLOR = {
 };
 const REASON_LABEL = {
     needs_human: "Needs-human todo",
+    questions_pending: "Pending question",
     dead_lead_pane: "Lead pane is dead",
     missing_root_with_work: "Project folder is missing",
     worker_needs_input: "A worker is waiting for input",
@@ -210,10 +211,12 @@ function footCounts(p, asOf, rank) {
         (rank ? `<span class="age">seen ${esc(age(p.last_activity_at, asOf))}</span>` : ""));
 }
 function movingBadges(p) {
-    if (p.lane !== "moving")
-        return "";
-    return ((p.needs_human > 0 ? `<span class="n-needs">${p.needs_human} need you</span>` : "") +
-        (p.todos.blocked_in_progress > 0 ? `<span class="n-muted">${p.todos.blocked_in_progress} blocked</span>` : ""));
+    const questions = p.questions_pending > 0
+        ? `<span class="n-questions">${p.questions_pending} question${p.questions_pending === 1 ? "" : "s"}</span>`
+        : "";
+    return ((p.lane === "moving" && p.needs_human > 0 ? `<span class="n-needs">${p.needs_human} need you</span>` : "") +
+        questions +
+        (p.lane === "moving" && p.todos.blocked_in_progress > 0 ? `<span class="n-muted">${p.todos.blocked_in_progress} blocked</span>` : ""));
 }
 function card(p, report, rank, href) {
     const asOf = report.as_of;
@@ -226,7 +229,7 @@ function card(p, report, rank, href) {
         items.push(`<li><span class="ref">+${p.needs_human - p.needs_human_items.length} more</span></li>`);
     }
     for (const r of p.reasons) {
-        if (r === "needs_human" || r === "quiet")
+        if (r === "needs_human" || r === "questions_pending" || r === "quiet")
             continue;
         const cls = REASON_SEVERE.has(r) ? " age-fail" : "";
         items.push(`<li><span class="${cls.trim()}">${esc(REASON_LABEL[r])}</span></li>`);
@@ -263,19 +266,22 @@ function gridRow(p, asOf, href) {
         `<span class="c-work">${workersCell(p)}</span>` +
         `<span class="c-n g-num">${num(t.open)}</span><span class="c-n g-num">${num(t.in_progress)}</span>` +
         `<span class="c-n g-num">${num(t.blocked, "n-blocked")}</span><span class="c-n g-num">${num(t.high, "n-high")}</span>` +
-        `<span class="c-n g-num">${num(p.needs_human, "n-needs")}</span><span class="c-n g-num c-wake">${wakesCell(p)}</span>` +
+        `<span class="c-n g-num">${num(p.needs_human, "n-needs")}</span>` +
+        `<span class="c-n g-num">${num(p.questions_pending, "n-questions")}</span>` +
+        `<span class="c-n g-num c-wake">${wakesCell(p)}</span>` +
         `<span class="c-last g-num age">${esc(age(p.last_activity_at, asOf))}</span>` +
         '<span class="c-nums">' +
         `<span>${t.open} open</span><span>${t.in_progress} doing</span>` +
         (t.blocked ? `<span class="n-blocked">${t.blocked} blocked</span>` : "") +
         (t.high ? `<span class="n-high">${t.high} high</span>` : "") +
         (p.needs_human ? `<span class="n-needs">${p.needs_human} need you</span>` : "") +
+        (p.questions_pending ? `<span class="n-questions">${p.questions_pending} question${p.questions_pending === 1 ? "" : "s"}</span>` : "") +
         wakesText(p) +
         "</span></div>");
 }
 const GRID_HEAD = '<div class="g-row g-head" role="row"><span>Project</span><span>Lead</span><span>Workers</span>' +
     '<span class="g-num">Open</span><span class="g-num">Doing</span><span class="g-num">Blocked</span>' +
-    '<span class="g-num">High</span><span class="g-num">Needs you</span><span class="g-num c-wake">Wakes</span>' +
+    '<span class="g-num">High</span><span class="g-num">Needs you</span><span class="g-num">Questions</span><span class="g-num c-wake">Wakes</span>' +
     '<span class="g-num">Last seen</span></div>';
 function laneName(lane) {
     return LANE_TITLE[lane].toLowerCase();
@@ -409,7 +415,7 @@ a.proj:hover { color: var(--accent); text-decoration: underline; text-underline-
 .drift { margin: 0.5rem 0 0; grid-column: 1 / -1; padding: 0.55rem 0.75rem; border-radius: var(--r-ctl); background: var(--warn-bg); color: var(--fg); font-size: 0.8125rem; }
 .drift strong { color: var(--warn); font-weight: 650; }
 .grid { display: grid; }
-.g-row { display: grid; grid-template-columns: minmax(8.5rem, 1.3fr) 10.5rem minmax(8rem, 1.2fr) repeat(4, 3.2rem) 4.6rem 5.2rem 5.6rem; align-items: center; gap: 0.6rem; padding: 0.5rem 1.1rem; border-top: 1px solid var(--border); font-size: 0.875rem; }
+.g-row { display: grid; grid-template-columns: minmax(8.5rem, 1.3fr) 10.5rem minmax(8rem, 1.2fr) repeat(4, 3.2rem) 4.6rem 4.6rem 5.2rem 5.6rem; align-items: center; gap: 0.6rem; padding: 0.5rem 1.1rem; border-top: 1px solid var(--border); font-size: 0.875rem; }
 .g-row:hover:not(.g-head) { background: var(--hover); }
 .g-head { font-size: 0.75rem; color: var(--fg-subtle); font-weight: 550; border-top: 0; padding-block: 0.2rem 0.4rem; }
 .g-num { font-family: var(--font-mono); font-variant-numeric: tabular-nums; text-align: right; }

package/dist/questions.js

@@ -0,0 +1,279 @@
+import { db } from "./db.js";
+import { HUMAN_ACTOR_PREFIX } from "./context.js";
+import { assertSafeWakeBody, resolveWakeDelivery } from "./tools/wakes.js";
+const QUESTION_STATE_CONFLICT = "QUESTION_STATE_CONFLICT";
+const HEADER_MAX_CHARS = 12;
+const MIN_OPTIONS = 2;
+const MAX_OPTIONS = 4;
+function toRecord(row) {
+    const { ref_kind, ref_number, options, ...rest } = row;
+    return {
+        ...rest,
+        options: options === null ? null : JSON.parse(options),
+        ref: ref_kind === null || ref_number === null ? null : { kind: ref_kind, number: ref_number },
+    };
+}
+const blank = (s) => typeof s !== "string" || s.trim() === "";
+function validateRef(ref) {
+    if (ref === undefined)
+        return;
+    if (ref.kind !== "todo" && ref.kind !== "pr")
+        throw new Error(`ref.kind must be "todo" or "pr", got ${JSON.stringify(ref.kind)}.`);
+    if (!Number.isSafeInteger(ref.number) || ref.number <= 0)
+        throw new Error("ref.number must be a positive safe integer.");
+}
+function validateInput(input) {
+    if (input.kind !== "choice" && input.kind !== "free_text") {
+        throw new Error(`kind must be "choice" or "free_text", got ${JSON.stringify(input.kind)}.`);
+    }
+    if (blank(input.question))
+        throw new Error("question cannot be blank.");
+    if (blank(input.header))
+        throw new Error("header cannot be blank.");
+    if ([...input.header].length > HEADER_MAX_CHARS) {
+        throw new Error(`header is ${[...input.header].length} characters; the limit is ${HEADER_MAX_CHARS}.`);
+    }
+    if (blank(input.default_answer))
+        throw new Error("default_answer cannot be blank: every question carries its default.");
+    validateRef(input.ref);
+    const wakeBound = [input.question, input.header, input.default_answer];
+    if (input.kind === "free_text") {
+        if (input.options !== undefined)
+            throw new Error("a free_text question takes no options.");
+    }
+    else {
+        const options = input.options;
+        if (!Array.isArray(options) || options.length < MIN_OPTIONS || options.length > MAX_OPTIONS) {
+            throw new Error(`a choice question needs ${MIN_OPTIONS} to ${MAX_OPTIONS} options, got ${Array.isArray(options) ? options.length : 0}.`);
+        }
+        const labels = new Set();
+        for (const o of options) {
+            if (blank(o.label))
+                throw new Error("an option label cannot be blank.");
+            if (blank(o.description))
+                throw new Error(`option "${o.label}" needs a description.`);
+            if (labels.has(o.label))
+                throw new Error(`option label "${o.label}" is duplicated; labels must be distinct.`);
+            labels.add(o.label);
+            wakeBound.push(o.label, o.description);
+        }
+        const recommended = options.filter((o) => o.recommended);
+        if (recommended.length !== 1) {
+            throw new Error(`exactly one option must be recommended, got ${recommended.length}.`);
+        }
+        if (input.default_answer !== recommended[0].label) {
+            throw new Error(`default_answer must be the recommended option's label ("${recommended[0].label}").`);
+        }
+    }
+    for (const text of wakeBound)
+        assertSafeWakeBody(text);
+}
+const tokensOf = (text) => new Set((text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []).filter((t) => [...t].length >= 4));
+const normalized = (text) => text.trim().replace(/\s+/g, " ").toLowerCase();
+export function looksSimilar(a, b) {
+    if (normalized(a) === normalized(b))
+        return true;
+    const ta = tokensOf(a);
+    const tb = tokensOf(b);
+    let shared = 0;
+    for (const t of ta)
+        if (tb.has(t))
+            shared++;
+    const union = ta.size + tb.size - shared;
+    return union > 0 && shared / union >= 0.5;
+}
+function similarPendingIds(projectId, selfId, question) {
+    const rows = db
+        .prepare("SELECT id, question FROM questions WHERE project_id = ? AND state = 'pending' AND id != ? ORDER BY id")
+        .all(projectId, selfId);
+    return rows.filter((r) => looksSimilar(question, r.question)).map((r) => r.id);
+}
+function runningAgentOf(projectId, actor) {
+    const row = db
+        .prepare("SELECT id FROM agents WHERE project_id = ? AND actor_id = ? AND status = 'running' ORDER BY id DESC LIMIT 1")
+        .get(projectId, actor);
+    return row?.id ?? null;
+}
+function runningLeadOf(projectId) {
+    const row = db
+        .prepare("SELECT id, actor_id FROM agents WHERE project_id = ? AND kind = 'lead' AND status = 'running' ORDER BY id DESC LIMIT 1")
+        .get(projectId);
+    return row ?? null;
+}
+const optionsJson = (input) => (input.kind === "choice" ? JSON.stringify(input.options) : null);
+function pendingIdForRef(projectId, ref) {
+    const row = db
+        .prepare("SELECT id FROM questions WHERE project_id = ? AND ref_kind = ? AND ref_number = ? AND state = 'pending'")
+        .get(projectId, ref.kind, ref.number);
+    return row?.id;
+}
+const upsertQuestion = db.transaction((projectId, actor, input, askerChecked) => {
+    if (input.ref) {
+        const existing = pendingIdForRef(projectId, input.ref);
+        if (existing !== undefined) {
+            db.prepare(`UPDATE questions SET kind = ?, question = ?, header = ?, options = ?, default_answer = ?,
+             updated_at = datetime('now'), updated_by = ? WHERE id = ?`).run(input.kind, input.question, input.header, optionsJson(input), input.default_answer, actor, existing);
+            return { id: existing, created: false };
+        }
+    }
+    if (!askerChecked) {
+        throw new Error(`${QUESTION_STATE_CONFLICT}: the pending question for this ref changed while it was being asked; ask again.`);
+    }
+    const row = db
+        .prepare(`INSERT INTO questions (project_id, asker, kind, question, header, options, default_answer,
+           ref_kind, ref_number, updated_by)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id`)
+        .get(projectId, actor, input.kind, input.question, input.header, optionsJson(input), input.default_answer, input.ref?.kind ?? null, input.ref?.number ?? null, actor);
+    return { id: row.id, created: true };
+});
+export function askQuestion(projectId, actor, input) {
+    validateInput(input);
+    const refTaken = input.ref !== undefined && pendingIdForRef(projectId, input.ref) !== undefined;
+    let askerChecked = false;
+    if (!refTaken) {
+        resolveWakeDelivery(projectId);
+        askerChecked = runningAgentOf(projectId, actor) !== null;
+        if (!askerChecked) {
+            throw new Error("This session has no running hive agent row, so an answer could never be woken back to it; a question needs an asker that can be woken.");
+        }
+    }
+    const { id, created } = upsertQuestion.immediate(projectId, actor, input, askerChecked);
+    return { question_id: id, created, similar_question_ids: similarPendingIds(projectId, id, input.question) };
+}
+function fetchRow(projectId, id) {
+    const row = db.prepare("SELECT * FROM questions WHERE project_id = ? AND id = ?").get(projectId, id);
+    if (!row)
+        throw new Error(`No question ${id} in this project. Call question_list.`);
+    return row;
+}
+export function getQuestion(projectId, id) {
+    return toRecord(fetchRow(projectId, id));
+}
+export function listQuestions(projectId) {
+    const rows = db
+        .prepare("SELECT * FROM questions WHERE project_id = ? AND state IN ('pending', 'defaulted') ORDER BY (state = 'defaulted'), id")
+        .all(projectId);
+    return rows.map(toRecord);
+}
+export function pendingQuestionCount(projectId) {
+    return db.prepare("SELECT COUNT(*) AS n FROM questions WHERE project_id = ? AND state = 'pending'").get(projectId).n;
+}
+const TEXT_PATCH_KEYS = ["question", "header", "options", "default_answer"];
+const patchQuestion = db.transaction((projectId, actor, id, patch) => {
+    const current = toRecord(fetchRow(projectId, id));
+    const editsText = TEXT_PATCH_KEYS.some((k) => patch[k] !== undefined);
+    if (editsText && current.state !== "pending") {
+        throw new Error(`${QUESTION_STATE_CONFLICT}: question ${id} is ${current.state}; only a pending question's text can be edited.`);
+    }
+    if (patch.state !== undefined) {
+        if (patch.state !== "defaulted" && patch.state !== "withdrawn") {
+            throw new Error(`state must be "defaulted" or "withdrawn", got ${JSON.stringify(patch.state)}.`);
+        }
+        const allowed = patch.state === "withdrawn" ? ["pending", "defaulted"] : ["pending"];
+        if (!allowed.includes(current.state)) {
+            throw new Error(`${QUESTION_STATE_CONFLICT}: question ${id} is ${current.state} and cannot become ${patch.state}.`);
+        }
+        if (actor !== current.asker && !actor.startsWith(HUMAN_ACTOR_PREFIX)) {
+            throw new Error(`Only the asking session (${current.asker}) or the human can mark question ${id} ${patch.state}.`);
+        }
+    }
+    let merged = null;
+    if (editsText) {
+        if (current.kind === "free_text" && patch.options !== undefined)
+            throw new Error("a free_text question takes no options.");
+        const base = {
+            question: patch.question ?? current.question,
+            header: patch.header ?? current.header,
+            default_answer: patch.default_answer ?? current.default_answer,
+            ...(current.ref ? { ref: current.ref } : {}),
+        };
+        merged =
+            current.kind === "choice"
+                ? { kind: "choice", ...base, options: patch.options ?? current.options }
+                : { kind: "free_text", ...base };
+        validateInput(merged);
+    }
+    const sets = ["updated_at = datetime('now')", "updated_by = ?"];
+    const params = [actor];
+    if (merged) {
+        sets.push("question = ?", "header = ?", "options = ?", "default_answer = ?");
+        params.push(merged.question, merged.header, optionsJson(merged), merged.default_answer);
+    }
+    if (patch.state !== undefined) {
+        sets.push("state = ?");
+        params.push(patch.state);
+    }
+    db.prepare(`UPDATE questions SET ${sets.join(", ")} WHERE id = ?`).run(...params, id);
+    return { question_id: id, state: patch.state ?? current.state };
+});
+export function updateQuestion(projectId, actor, id, patch) {
+    if (Object.keys(patch).filter((k) => patch[k] !== undefined).length === 0) {
+        throw new Error("an empty patch changes nothing; pass at least one field to change.");
+    }
+    return patchQuestion.immediate(projectId, actor, id, patch);
+}
+export function answerWakeBody(id, question, answer, notes) {
+    const head = `Question #${id} answered.\nQuestion: ${question}\nAnswer: ${answer}`;
+    return notes !== null && notes.trim() !== "" ? `${head}\nNotes: ${notes}` : head;
+}
+function planAnswerWake(projectId, row, actor) {
+    if (actor === row.asker)
+        return { skipped: "answered by the asker" };
+    const agentId = runningAgentOf(projectId, row.asker);
+    if (agentId === null) {
+        const lead = runningLeadOf(projectId);
+        if (lead === null)
+            return { skipped: `the asker ${row.asker} has no running agent` };
+        if (lead.actor_id === actor)
+            return { skipped: "answered by the lead that would receive it" };
+        try {
+            return { delivery: resolveWakeDelivery(projectId, lead.id), reroutedFrom: row.asker };
+        }
+        catch (e) {
+            return { skipped: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    try {
+        return { delivery: resolveWakeDelivery(projectId, agentId) };
+    }
+    catch (e) {
+        return { skipped: e instanceof Error ? e.message : String(e) };
+    }
+}
+const commitAnswer = db.transaction((projectId, actor, id, answer, notes, plan) => {
+    const row = fetchRow(projectId, id);
+    if (row.state !== "pending" && row.state !== "defaulted") {
+        throw new Error(`${QUESTION_STATE_CONFLICT}: question ${id} is already ${row.state}.`);
+    }
+    db.prepare(`UPDATE questions SET state = 'answered', answer = ?, notes = ?, answered_by = ?, updated_by = ?,
+         updated_at = datetime('now') WHERE id = ?`).run(answer, notes, actor, actor, id);
+    if ("skipped" in plan)
+        return { question_id: id, wake_id: null, wake_skipped: plan.skipped };
+    const body = answerWakeBody(id, row.question, answer, notes);
+    const wakeBody = "reroutedFrom" in plan && plan.reroutedFrom !== undefined
+        ? `${body}\nAsked by ${plan.reroutedFrom}, which is not running; delivered to this project's lead.`
+        : body;
+    const wake = db
+        .prepare(`INSERT INTO wakes (project_id, owner, body, kind, deliver_actor, deliver_pane, due_at)
+         VALUES (?, ?, ?, 'delay', ?, ?, datetime('now')) RETURNING id`)
+        .get(projectId, actor, wakeBody, plan.delivery.actor, plan.delivery.pane);
+    return {
+        question_id: id,
+        wake_id: wake.id,
+        ...("reroutedFrom" in plan && plan.reroutedFrom !== undefined ? { wake_rerouted_to: plan.delivery.actor } : {}),
+    };
+});
+export function answerQuestion(projectId, actor, id, answer, notes) {
+    if (blank(answer))
+        throw new Error("answer cannot be blank.");
+    const storedNotes = notes === undefined || notes.trim() === "" ? null : notes;
+    assertSafeWakeBody(answer);
+    if (storedNotes !== null)
+        assertSafeWakeBody(storedNotes);
+    const row = fetchRow(projectId, id);
+    if (row.state !== "pending" && row.state !== "defaulted") {
+        throw new Error(`${QUESTION_STATE_CONFLICT}: question ${id} is already ${row.state}.`);
+    }
+    const plan = planAnswerWake(projectId, row, actor);
+    return commitAnswer.immediate(projectId, actor, id, answer, storedNotes, plan);
+}