@cmgmyr/hive 1.11.0 → 1.11.2

package/README.md

@@ -70,6 +70,7 @@ hive is a personal daily-driver tool, released low-key. It is single-user by des
 | [Dashboard](docs/dashboard.md) | The generated dashboard: enabling it, where it lives, what it shows |
 | [Install details](docs/install.md) | The interpreter pin, iTerm settings, the status line, MCP scope, codex workers, updating, uninstalling |
 | [Troubleshooting](docs/troubleshooting.md) | Common errors and their fixes |
+| [Security](docs/security.md) | What hive runs, writes and fetches on your machine, with the code to check |
 | [Tools](docs/tools.md) | The MCP tools: what each does and when to use it |
 | [tmux settings](docs/tmux.md) | Attach modes, pane options, and what to put in `~/.tmux.conf` |
 | [Development](docs/development.md) | Building and testing hive itself |

package/dist/build-info.json

@@ -1 +1 @@
-{"version":"1.11.0","sha":"7534ff6","dirty":false,"build_id":"bd31535e0eaed043ebe60b90c2e95925e21567baf82b5142e3a6c0e6908a58ac"}
+{"version":"1.11.2","sha":"6919b35","dirty":false,"build_id":"f1a0c66c3af90eb5af9a295a8b233d987cf4133f6355eea5cf46b87f5289e0bd"}

package/dist/cli.js

@@ -78,7 +78,7 @@ Usage:
                              snapshot; read-only, writes nothing
   hive portfolio [--json]    one row per registered project: lane, lead, workers,
                              todos, needs-human count, wakes; read-only
-  hive queen-audit           confirmed queen writes, newest first; 30-day history
+  hive queen-audit           queen writes and refused calls, newest first; 30-day history
     [--project-id <id>]      filter the target project (queen only across projects)
     [--limit <n>] [--json]   default 20, maximum 100; JSON prints one object
   hive next [--print]        attach to the lead of the project that needs you most
@@ -590,9 +590,10 @@ async function cmdLead(argv) {
         try {
             wonRace = db.transaction(() => {
                 const updated = db
-                    .prepare("UPDATE agents SET tmux_target = ?, tmux_socket = ?, pane_pid = ?, command = ?, codex_home = ? " +
+                    .prepare("UPDATE agents SET tmux_target = ?, tmux_socket = ?, pane_pid = ?, command = ?, codex_home = ?, " +
+                    "pane_started_at = CASE WHEN ? = 1 THEN strftime('%Y-%m-%d %H:%M:%f', 'now') ELSE pane_started_at END " +
                     "WHERE id = ? AND tmux_target = ? AND tmux_socket = ? AND pane_pid = ? AND status = 'running'")
-                    .run(leadPane, tmuxSocketPath(process.env.TMUX, process.env.TMUX_TMPDIR), recordedPanePid, recordedCommand, recordedCodexHome, leadAgentId, casExpected, casSocket, casPid).changes;
+                    .run(leadPane, tmuxSocketPath(process.env.TMUX, process.env.TMUX_TMPDIR), recordedPanePid, recordedCommand, recordedCodexHome, createdPane ? 1 : 0, leadAgentId, casExpected, casSocket, casPid).changes;
                 if (updated === 0)
                     return false;
                 db.prepare(`UPDATE wakes SET deliver_pane = ?, held_at = NULL, held_reason = NULL
@@ -2857,19 +2858,20 @@ function canonicalPath(path) {
 function nextCandidates() {
     const queenRoot = canonicalPath(join(storeDir(), "queen"));
     const byCount = (a, b) => b - a;
+    const waitsOnYou = (p) => p.needs_human + p.questions_pending;
     return collectPortfolio()
-        .projects.filter((p) => (p.lane === "waiting_on_you" || p.lane === "stuck" || (p.lane === "moving" && p.needs_human > 0)) &&
+        .projects.filter((p) => (p.lane === "waiting_on_you" || p.lane === "stuck" || (p.lane === "moving" && waitsOnYou(p) > 0)) &&
         canonicalPath(p.root) !== queenRoot)
         .sort((a, b) => {
-        const tier = (p) => (p.lane === "waiting_on_you" ? 0 : p.needs_human > 0 ? 1 : 2);
+        const tier = (p) => (p.lane === "waiting_on_you" ? 0 : waitsOnYou(p) > 0 ? 1 : 2);
         if (tier(a) !== tier(b))
             return tier(a) - tier(b);
         if (a.lane === "waiting_on_you") {
-            return (byCount(a.needs_human, b.needs_human) ||
+            return (byCount(waitsOnYou(a), waitsOnYou(b)) ||
                 a.last_activity_at.localeCompare(b.last_activity_at) ||
                 a.id - b.id);
         }
-        return (byCount(a.needs_human, b.needs_human) ||
+        return (byCount(waitsOnYou(a), waitsOnYou(b)) ||
             byCount(a.todos.blocked_in_progress, b.todos.blocked_in_progress) ||
             byCount(a.wakes.overdue, b.wakes.overdue) ||
             byCount(a.workers.needs_input, b.workers.needs_input) ||
@@ -2948,7 +2950,7 @@ function cmdQueenAudit(argv) {
         return;
     }
     if (report.entries.length === 0) {
-        console.log("No queen actions recorded.");
+        console.log("No queen audit entries recorded.");
         return;
     }
     for (const entry of report.entries) {
@@ -3371,6 +3373,9 @@ function cmdAnswer(argv) {
     if (receipt.wake_id === null) {
         console.log(`No wake queued: ${receipt.wake_skipped ?? "the asking session could not be reached"}.`);
     }
+    else if (receipt.wake_rerouted_to) {
+        console.log(`Wake #${receipt.wake_id} queued for ${receipt.wake_rerouted_to}; the asker is not running.`);
+    }
     else {
         console.log(`Wake #${receipt.wake_id} queued for the asking session.`);
     }

package/dist/context.js

@@ -5,6 +5,8 @@ import { basename, dirname, join, resolve, sep } from "node:path";
 import { storeDir } from "./dataDir.js";
 import { db } from "./db.js";
 import { LEAD_KIND } from "./spawn.js";
+import { rowOwnership } from "./tmux.js";
+import { recordQueenRefusal } from "./queenAudit.js";
 let selectedId = null;
 let cachedActorId = null;
 let lastTouchMs = 0;
@@ -294,6 +296,30 @@ export function captureQueenWriteIdentity(targetProjectId) {
         return null;
     return { actor_id: process.env.HIVE_AGENT_ID, home_project_id: home };
 }
+export function resolveQueenLeadTarget(operation, targetProjectId, ref, resolve) {
+    if (!captureQueenWriteIdentity(targetProjectId))
+        return resolve();
+    let agent;
+    try {
+        agent = resolve();
+    }
+    catch (e) {
+        throw queenRefusal(operation, targetProjectId, `recipient ${JSON.stringify(ref)} could not be resolved: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const ownership = rowOwnership(agent);
+    const problem = agent.project_id !== targetProjectId
+        ? `Agent ${agent.id} ("${agent.name}") belongs to project ${agent.project_id}, not project ${targetProjectId}`
+        : agent.kind !== LEAD_KIND
+            ? `Agent ${agent.id} ("${agent.name}") is kind "${agent.kind}", not a lead`
+            : agent.status !== "running"
+                ? `Agent ${agent.id} ("${agent.name}") is ${agent.status}, not running`
+                : ownership !== "live"
+                    ? `Agent ${agent.id} ("${agent.name}") does not own a live pane (ownership: ${ownership})`
+                    : null;
+    if (problem)
+        throw queenRefusal(operation, targetProjectId, problem);
+    return agent;
+}
 export const QUEEN_REACH = {
     whoami: "read",
     help: "read",
@@ -379,7 +405,7 @@ function foreignWriteProblem(reach, targetProjectId, args) {
             const lead = runningLead(targetProjectId);
             if (!lead)
                 return "that project has no running lead to address";
-            if (!namesLead(args.deliver_to, lead)) {
+            if (args.deliver_to == null) {
                 return `deliver_to must name that project's running lead ("${lead.name}" or agent id ${lead.id})`;
             }
             return null;
@@ -402,8 +428,8 @@ function foreignWriteProblem(reach, targetProjectId, args) {
             const lead = runningLead(targetProjectId);
             if (!lead)
                 return "that project has no running lead to address";
-            if (!namesLead(args.agent_id ?? args.name, lead)) {
-                return `the recipient must be that project's running lead ("${lead.name}" or agent id ${lead.id})`;
+            if (args.agent_id == null && args.name == null) {
+                return `the recipient must name that project's running lead ("${lead.name}" or agent id ${lead.id})`;
             }
             return null;
         }
@@ -446,8 +472,20 @@ export function assertQueenToolCall(tool, args) {
 function queenRefusal(operation, targetProjectId, problem) {
     const target = targetProjectId === null ? null : getProject(targetProjectId);
     const where = target ? `in project ${target.id} ("${target.name}")` : "outside the queen's own project";
-    return new Error(`${QUEEN_REFUSAL}: the queen cannot run ${operation} ${where}: ${problem}. Into another project the ` +
+    const refusal = new Error(`${QUEEN_REFUSAL}: the queen cannot run ${operation} ${where}: ${problem}. Into another project the ` +
         "queen may only todo_create, todo_comment, send text or wakes to its running lead, start its lead " +
         "with `hive lead <path>`, and run project_prune or `hive project rm` on it. Everything else there is its lead's to do.");
+    if (targetProjectId !== null) {
+        const identity = captureQueenWriteIdentity(targetProjectId);
+        if (identity) {
+            try {
+                recordQueenRefusal(operation, targetProjectId, problem, identity);
+            }
+            catch {
+                // A refusal must survive an unavailable audit write.
+            }
+        }
+    }
+    return refusal;
 }
 export const HUMAN_ACTOR_PREFIX = "user:";

package/dist/dashboard.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
 import { db } from "./db.js";
 import { getProject } from "./context.js";
 export const describeVisibility = (visibility) => visibility === null ? "running" : visibility === "window" ? "own window" : visibility;
@@ -12,6 +13,7 @@ export function processCounts(procs) {
 }
 import { awaitingFirstPrompt } from "./firstPrompt.js";
 import { SLUG_MAX_LEN, cutToUnitBudget } from "./slug.js";
+const requireFromHere = createRequire(import.meta.url);
 export const TODO_CAP = 100;
 export const AGENT_CAP = 50;
 export const WAKE_CAP = 50;
@@ -449,6 +451,45 @@ function renderWakesSection(index, projectId) {
     const body = renderCappedList(shown.length, all.length, "pending wakes", "wakes", rows, emptyState("No pending wakes.", "Scheduled and idle-triggered check-ins from wake_set show up here."));
     return section(index, "wakes", "Wakes", `${all.length} pending`, "bell", String(shown.length), body);
 }
+function questionAge(createdAt) {
+    const timestamp = Date.parse(`${createdAt.replace(" ", "T")}Z`);
+    if (!Number.isFinite(timestamp))
+        return "unknown";
+    const seconds = Math.max(0, Math.floor((Date.now() - timestamp) / 1000));
+    if (seconds >= 86400)
+        return `${Math.floor(seconds / 86400)}d ago`;
+    if (seconds >= 3600)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    if (seconds >= 60)
+        return `${Math.floor(seconds / 60)}m ago`;
+    return "now";
+}
+function renderQuestionsSection(index, projectId) {
+    // A static import of questions.js cycles through tools/wakes.ts and scheduler.ts.
+    const { listQuestions, pendingQuestionCount } = requireFromHere("./questions.js");
+    const questions = listQuestions(projectId);
+    if (questions.length === 0)
+        return "";
+    const pendingCount = pendingQuestionCount(projectId);
+    const rows = questions.map((question) => {
+        const options = question.kind === "free_text"
+            ? '<p class="question-options">free text</p>'
+            : `<ul class="question-options">${(question.options ?? []).map((option) => `<li>${prose(option.label)}${option.recommended ? ' <span class="recommended">recommended</span>' : ""}` +
+                `<span class="question-option-description">${prose(option.description)}</span></li>`).join("")}</ul>`;
+        const ref = question.ref ? `<span class="question-ref">${question.ref.kind === "todo" ? "todo" : "PR"} #${question.ref.number}</span>` : "";
+        const state = question.state === "defaulted"
+            ? '<span class="question-state">defaulted - proceeding on the default</span>'
+            : '<span class="question-state">pending</span>';
+        return (`<li class="question" data-question="${question.id}"><div class="question-head">${mono(`#${question.id}`)} ` +
+            `<strong>${escapeHtml(question.header)}</strong> ${state}</div>` +
+            `<p class="question-text">${prose(question.question)}</p>${options}` +
+            `<p class="question-default">Default answer: ${prose(question.default_answer)}</p>` +
+            `<p class="question-meta">Asked by ${mono(question.asker)} · ${escapeHtml(questionAge(question.created_at))}` +
+            `${ref ? ` · ${ref}` : ""}</p>` +
+            `<p class="question-answer">To answer: <code>hive answer ${question.id}</code></p></li>`);
+    }).join("\n");
+    return section(index, "questions", "Questions", `${pendingCount} pending`, "inbox", String(pendingCount), `<ul class="question-list">${rows}</ul>`);
+}
 function fetchCommentActivity(projectId) {
     const rows = db
         .prepare(`SELECT c.id, c.body, c.author, c.created_at, t.id AS todo_id, t.title AS todo_title,
@@ -682,6 +723,15 @@ export const SECTION_STYLE = `
   .priority-low { color: var(--fg-subtle); }
   .blockers { font-size: 0.8125rem; color: var(--fg-muted); margin: 0 0 0.45rem 0.6rem; }
   .wake-body { color: var(--fg); font-size: 0.875rem; overflow-wrap: anywhere; }
+  .question-list { display: grid; gap: 0.85rem; list-style: none; margin: 0; padding: 0; }
+  .question { border-bottom: 1px solid var(--border); padding-bottom: 0.85rem; overflow-wrap: anywhere; }
+  .question:last-child { border-bottom: 0; padding-bottom: 0; }
+  .question-head, .question-meta, .question-answer, .question-default, .question-text, .question-options { margin: 0.2rem 0; }
+  .question-head, .question-meta, .question-answer { font-size: 0.8125rem; }
+  .question-state, .question-ref, .recommended { color: var(--fg-muted); font-size: 0.75rem; }
+  .question-options { padding-left: 1.2rem; }
+  .question-option-description { display: block; padding-left: 0.5rem; color: var(--fg-muted); }
+  .question-text { overflow-wrap: anywhere; white-space: pre-wrap; }
   .activity-body { font-size: 0.8125rem; color: var(--fg-muted); white-space: pre-wrap;
     overflow-wrap: anywhere; margin-top: 0.1rem; }
 
@@ -1171,7 +1221,9 @@ function buildDashboard(projectId, procs) {
     const project = fetchProject(projectId);
     const stats = fetchDayStats(projectId);
     const index = [];
+    const questionsSection = renderQuestionsSection(index, projectId);
     const cards = [
+        ...(questionsSection ? [questionsSection] : []),
         renderThroughputSection(index, stats),
         renderBoardSection(index, projectId),
         renderTodosSection(index, projectId),

package/dist/db.js

@@ -568,6 +568,14 @@ CREATE TABLE questions (
 CREATE UNIQUE INDEX idx_questions_pending_ref ON questions(project_id, ref_kind, ref_number)
   WHERE state = 'pending' AND ref_kind IS NOT NULL;
 CREATE INDEX idx_questions_project_state ON questions(project_id, state, id);
+`,
+    `
+ALTER TABLE queen_audit ADD COLUMN outcome TEXT NOT NULL DEFAULT 'confirmed'
+  CHECK (outcome IN ('confirmed', 'refused'));
+ALTER TABLE queen_audit ADD COLUMN problem TEXT NOT NULL DEFAULT '';
+`,
+    `
+ALTER TABLE agents ADD COLUMN pane_started_at TEXT;
 `,
 ];
 export function storeSchemaAhead(database) {

package/dist/portfolio.js

@@ -8,6 +8,7 @@ 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",
@@ -136,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))
@@ -173,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";
@@ -192,7 +196,7 @@ function projectRow(project, now, snapshot) {
         workers,
         todos,
         needs_human: tagged.length,
-        questions_pending: pendingQuestionCount(project.id),
+        questions_pending: questionsPending,
         needs_human_items: tagged.slice(0, NEEDS_HUMAN_ITEM_CAP).map((t) => ({
             todo_id: t.id,
             title: t.title,

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

@@ -94,6 +94,12 @@ function runningAgentOf(projectId, actor) {
         .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
@@ -214,8 +220,19 @@ function planAnswerWake(projectId, row, actor) {
     if (actor === row.asker)
         return { skipped: "answered by the asker" };
     const agentId = runningAgentOf(projectId, row.asker);
-    if (agentId === null)
-        return { skipped: `the asker ${row.asker} has no running agent` };
+    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) };
     }
@@ -232,11 +249,19 @@ const commitAnswer = db.transaction((projectId, actor, id, answer, notes, plan)
          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, answerWakeBody(id, row.question, answer, notes), plan.delivery.actor, plan.delivery.pane);
-    return { question_id: id, wake_id: wake.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))

package/dist/scheduler.js

@@ -600,6 +600,8 @@ function holdTimer(timer, reason) {
          OR (${socketAwaitingWhere()}))`, reason, timer.id, timer.due_at, count, count);
 }
 const HELD_REASON_MODAL_CHOICE = "pane is awaiting a modal choice (folder-trust or /model picker)";
+const LEAD_BOOT_BOX_WAIT_MS = 60_000;
+const HELD_REASON_LEAD_BOOT_INPUT_BOX = "the lead's input box is not on screen yet; holding while its session starts";
 export const HELD_REASON_LEAD_PANE_DEAD = "the lead's pane is not live right now (likely mid-restart); lead-owned wakes are exempt from " +
     "cancellation for this alone, so it is held rather than lost";
 const HELD_REASON_PANE_REISSUED_PREFIX = "the pane id recorded for this wake now belongs to a different pane than the one it was set " +
@@ -664,6 +666,25 @@ export function isUnsubmittedInputHold(heldReason) {
 export const HELD_REASON_CONVERSATION = "a human talked to this lead more recently than the conversation-hold window; holding so a wake " +
     "does not split an in-progress discussion - it delivers once the window passes or the hold's own " +
     "ceiling is reached, whichever comes first";
+function leadBootSessionIsFresh(agentId, panePid) {
+    const row = stmt("SELECT pane_started_at FROM agents WHERE id = ? AND pane_pid = ?").get(agentId, panePid);
+    if (!row?.pane_started_at)
+        return false;
+    const timestamp = Date.parse(`${row.pane_started_at.replace(" ", "T")}Z`);
+    return Number.isFinite(timestamp) && Date.now() - timestamp < LEAD_BOOT_BOX_WAIT_MS;
+}
+function leadInputBoxObservation(pane, command, cache) {
+    const entry = cacheEntry(pane, cache);
+    if (entry.snapshot === undefined) {
+        entry.snapshot = paneClassifierFor(command)?.inputBoxSnapshot?.(pane) ?? null;
+    }
+    if (entry.snapshot === null) {
+        entry.box = null;
+        return { captured: false, box: null };
+    }
+    entry.box = entry.snapshot.box;
+    return { captured: true, box: entry.snapshot.box };
+}
 // A human message keeps a lead-bound wake held for this long after it lands. Measured deferral rates
 // for this and CONVERSATION_HOLD_MAX are in hive-internals/references/worker-state.md.
 const CONVERSATION_HOLD_TTL_SECONDS = 5 * 60;
@@ -1557,7 +1578,26 @@ function deliverable(timer, snapshot, choices) {
         noteModalHold(timer, snapshot);
         return { ok: false };
     }
-    if (inputBoxHoldsWake(timer.deliver_pane, timer.deliver_command, choices)) {
+    const claudeLeadSnapshot = isLeadActorId(timer.deliver_actor) && paneClassifierFor(timer.deliver_command)?.inputBoxSnapshot !== undefined;
+    if (claudeLeadSnapshot) {
+        const bootWindow = row.deliver_row_id !== null && leadBootSessionIsFresh(row.deliver_row_id, row.deliver_pane_pid);
+        const observation = leadInputBoxObservation(timer.deliver_pane, timer.deliver_command, choices);
+        if (!observation.captured) {
+            if (bootWindow)
+                return { ok: false };
+        }
+        else {
+            if (holdsHumanInput(observation.box)) {
+                noteUnsubmittedInputHold(timer, snapshot);
+                return { ok: false };
+            }
+            if (observation.box === null && bootWindow) {
+                holdTimer(timer, HELD_REASON_LEAD_BOOT_INPUT_BOX);
+                return { ok: false };
+            }
+        }
+    }
+    else if (inputBoxHoldsWake(timer.deliver_pane, timer.deliver_command, choices)) {
         noteUnsubmittedInputHold(timer, snapshot);
         return { ok: false };
     }

package/dist/staleServers.js

@@ -4,6 +4,19 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_DATA_DIR } from "./dataDir.js";
 export const STALE_SERVER_BOUNDARY_SLACK_MS = 3000;
+export function readProcessEnvironment(pid) {
+    try {
+        return execFileSync("ps", ["eww", "-p", String(pid), "-o", "command="], { encoding: "utf8" });
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "status" in error && error.status === 1 &&
+            "stdout" in error && String(error.stdout ?? "").trim() === "" &&
+            "stderr" in error && (String(error.stderr ?? "").trim() === "" || /no such process|process id .* (?:not found|does not exist)/i.test(String(error.stderr)))) {
+            return null;
+        }
+        throw error;
+    }
+}
 const serverEntrypoint = resolve(dirname(fileURLToPath(import.meta.url)), "index.js");
 export function elapsedSeconds(value) {
     const dayForm = /^(\d+)-(\d{1,2}):(\d{2}):(\d{2})$/.exec(value);
@@ -94,7 +107,7 @@ export function parseStaleHiveServers(psOutput, appliedAt, observedAt = Date.now
     }));
     return { servers };
 }
-export function staleHiveServers(appliedAt, dataDir = DEFAULT_DATA_DIR) {
+export function staleHiveServers(appliedAt, dataDir = DEFAULT_DATA_DIR, readEnvironment = readProcessEnvironment) {
     if (appliedAt === null)
         return { skipped: "the newest migration time is unavailable" };
     try {
@@ -104,9 +117,9 @@ export function staleHiveServers(appliedAt, dataDir = DEFAULT_DATA_DIR) {
             return parsed;
         const servers = [];
         for (const server of parsed.servers) {
-            const envOutput = execFileSync("ps", ["eww", "-p", String(server.pid), "-o", "command="], {
-                encoding: "utf8",
-            });
+            const envOutput = readEnvironment(server.pid);
+            if (envOutput === null)
+                continue;
             const sameStore = processUsesDataDir(envOutput, dataDir);
             if (sameStore === null)
                 return { skipped: "ps returned environment output that could not be parsed" };

package/dist/tools/agents.js

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { db } from "../db.js";
 import { confirmQueenWrite } from "../queenAudit.js";
-import { captureQueenWriteIdentity } from "../context.js";
+import { captureQueenWriteIdentity, resolveQueenLeadTarget } from "../context.js";
 import { agentBriefPath, mergedBriefVars, readAgentBrief, workerBrief, workerCommandString, writeAgentBrief, } from "../brief.js";
 import { codexHomeDir, codexInstructionsPhrase, codexLaunchArgs, ensureCodexHome, ensureCodexHooksFile, refreshCodexMcpEnv } from "../codexHome.js";
 import { currentActor, findProjectForDir, getProject, linkedWorktreePrimaryRoot, resolveProject } from "../context.js";
@@ -1171,7 +1171,7 @@ export function registerAgents(server) {
         },
     }, (args) => run(async () => {
         const project = resolveProject(args.project_id);
-        const agent = findAgent(project.id, args);
+        const agent = resolveQueenLeadTarget("agent_send", project.id, args.agent_id ?? args.name, () => findAgent(project.id, args));
         requireLive(agent);
         const target = agent.tmux_target;
         const auditIdentity = captureQueenWriteIdentity(project.id);

package/dist/tools/queenAudit.js

@@ -3,7 +3,7 @@ import { run } from "../result.js";
 import { idParam, limitParam } from "./params.js";
 export function registerQueenAudit(server) {
     server.registerTool("queen_audit_list", {
-        description: "List confirmed queen writes into other projects, newest first. The queen may read all targets; other callers see only their own project. Default 20, maximum 100 entries. History is retained for 30 days with a 20,000 id-range backstop. A crash between a completed terminal send and its audit insert can leave that send unrecorded.",
+        description: "List confirmed queen writes and refused cross-project guard calls, newest first. Refusal rows include outcome=refused and the problem. The queen may read all targets; other callers see only their own project. Default 20, maximum 100 entries. History is retained for 30 days with a 20,000 id-range backstop. A crash between a completed terminal send and its audit insert can leave that send unrecorded.",
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         inputSchema: {
             project_id: idParam.optional().describe("Filter by the target project id. Only the queen may name another project."),

package/dist/tools/questions.js

@@ -71,7 +71,7 @@ export function registerQuestions(server) {
         return updateQuestion(effectiveProjectId(), currentActor(), question_id, patch);
     }));
     server.registerTool("question_answer", {
-        description: "Record the human's answer to a pending or defaulted question in this project: a picked option label or free text (any nonblank text is accepted, including one outside the offered labels), plus optional notes. The answer commits first. It then queues one wake to the asking session carrying the question, answer and notes verbatim, unless you ARE the asker (you recorded the human's own pick) or the asker cannot be reached now; either way the receipt says wake_id null and why in wake_skipped, and the answer stays readable with question_get. wake_id means queued, not delivered. An answered or withdrawn question refuses with QUESTION_STATE_CONFLICT.",
+        description: "Record the human's answer to a pending or defaulted question in this project, plus optional notes. The answer may be a picked option label or free text, including text outside the offered labels. The answer update comes first; the answer and any wake commit together, and the answer stays readable with `question_get`. An answered or withdrawn question refuses with `QUESTION_STATE_CONFLICT`. A queued wake carries the question, answer and notes verbatim. When you are the asker, skip with `wake_id: null` and `wake_skipped`; otherwise, queue a wake to the running asker or, if the asker has no running row, to the project's running lead with `wake_rerouted_to`. Skip that fallback with `wake_id: null` and `wake_skipped` if no lead runs or the lead is the answerer. `wake_id` means queued, not delivered.",
         annotations: writes,
         inputSchema: {
             question_id: idParam,
@@ -82,6 +82,7 @@ export function registerQuestions(server) {
             question_id: idParam,
             wake_id: idParam.nullable(),
             wake_skipped: z.string().optional(),
+            wake_rerouted_to: z.string().optional(),
         },
     }, (args) => run(() => answerQuestion(effectiveProjectId(), currentActor(), args.question_id, args.answer, args.notes)));
 }

package/dist/tools/wakes.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { db } from "../db.js";
 import { commitQueenStateWrite } from "../queenAudit.js";
-import { currentActor, effectiveProjectId, getProject, isQueenLead } from "../context.js";
+import { captureQueenWriteIdentity, currentActor, effectiveProjectId, getProject, isQueenLead, resolveQueenLeadTarget, } from "../context.js";
 import { run } from "../result.js";
 import { findAgent, observeOwnership, notOwnedError, summaryLiveness } from "./agents.js";
 import { ACTIVE_TIMER_WHERE, LOG_RETENTION, OWNED_BY_WATCH, WATCH_SCOPE_PROJECT, seedGoneCursor, } from "../scheduler.js";
@@ -35,9 +35,11 @@ function refuseUnclassifiableTarget(agent) {
         "error you can read now. Drive this pane with agent_send(keys: [...]) instead, which is unguarded for " +
         "exactly this reason.");
 }
-export function resolveWakeDelivery(projectId, deliverTo) {
+export function resolveWakeDelivery(projectId, deliverTo, queenOperation) {
     if (deliverTo != null) {
-        const agent = resolveAgentRef(projectId, deliverTo);
+        const agent = queenOperation
+            ? resolveQueenLeadTarget(queenOperation, projectId, deliverTo, () => resolveAgentRef(projectId, deliverTo))
+            : resolveAgentRef(projectId, deliverTo);
         // Before the liveness probe: the harness is a durable fact about the row, while liveness is a
         // question about right now, so a dead bash worker should say what is actually wrong with it.
         refuseUnclassifiableTarget(agent);
@@ -52,18 +54,24 @@ export function resolveWakeDelivery(projectId, deliverTo) {
     const own = db
         .prepare("SELECT * FROM agents WHERE actor_id = ? AND status = 'running' ORDER BY id DESC LIMIT 1")
         .get(actor);
+    if (queenOperation && !own && captureQueenWriteIdentity(projectId)) {
+        resolveQueenLeadTarget(queenOperation, projectId, deliverTo, () => {
+            throw new Error("the calling session has no running agent row to receive this wake");
+        });
+    }
     // Checked on the ROW, not behind the liveness probe: isLive is three-state, and letting a null
     // fall through to the TMUX_PANE branch below accepts a wake the scheduler will then hold forever
     // against that same row's command - the never-firing timer this refusal exists to prevent.
-    if (own)
-        refuseUnclassifiableTarget(own);
-    if (own) {
-        const ownership = observeOwnership(own);
+    const target = own && queenOperation ? resolveQueenLeadTarget(queenOperation, projectId, deliverTo, () => own) : own;
+    if (target)
+        refuseUnclassifiableTarget(target);
+    if (target) {
+        const ownership = observeOwnership(target);
         if (ownership === "live")
-            return { actor, pane: own.tmux_target };
+            return { actor, pane: target.tmux_target };
         // Unknown never falls through to the ambient pane: that would bind this row's actor to a pane it may not own.
         if (ownership === "unknown")
-            throw notOwnedError(own, ownership);
+            throw notOwnedError(target, ownership);
     }
     const pane = process.env.TMUX_PANE;
     if (pane)
@@ -331,7 +339,7 @@ export function registerWakes(server) {
     }, (args) => run(() => {
         assertSafeWakeBody(args.body);
         const projectId = effectiveProjectId(args.project_id);
-        const delivery = resolveWakeDelivery(projectId, args.deliver_to);
+        const delivery = resolveWakeDelivery(projectId, args.deliver_to, "wake_set");
         return commitQueenStateWrite("wake_set", projectId, args, () => {
             const row = db
                 .prepare(`INSERT INTO wakes (project_id, owner, body, kind, deliver_actor, deliver_pane, due_at, repeat_every_ms)
@@ -441,7 +449,7 @@ export function registerWakes(server) {
                 "reported as a timeout instead of the failure it actually is. A lead's turn has its own channel, " +
                 "which only the queen may watch, with lead_project_id=<that lead's project id>.");
         }
-        const delivery = resolveWakeDelivery(projectId, args.deliver_to);
+        const delivery = resolveWakeDelivery(projectId, args.deliver_to, "wake_when_idle");
         const snapshot = liveTargets();
         if (mode === "all") {
             const allIdle = watched.every((a) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmgmyr/hive",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "Run a crew of Claude Code and Codex workers from one lead session: visible tmux panes, exact state from hooks, one local SQLite store.",
   "type": "module",
   "bin": {