@cmgmyr/hive 1.10.0 → 1.11.0

package/dist/staleServers.js

@@ -0,0 +1,122 @@
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+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;
+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);
+    const fields = dayForm ? dayForm.slice(2).map(Number) : value.split(":").map(Number);
+    if ((!dayForm && fields.length !== 2 && fields.length !== 3) || fields.some((field) => !Number.isSafeInteger(field) || field < 0)) {
+        return null;
+    }
+    let total;
+    if (dayForm) {
+        const [hours, minutes, seconds] = fields;
+        if (hours > 23 || minutes > 59 || seconds > 59)
+            return null;
+        total = (Number(dayForm[1]) * 24 + hours) * 3600 + minutes * 60 + seconds;
+    }
+    else if (fields.length === 2) {
+        const [minutes, seconds] = fields;
+        if (seconds > 59)
+            return null;
+        total = minutes * 60 + seconds;
+    }
+    else {
+        const [hours, minutes, seconds] = fields;
+        if (minutes > 59 || seconds > 59)
+            return null;
+        total = hours * 3600 + minutes * 60 + seconds;
+    }
+    return Number.isSafeInteger(total) ? total : null;
+}
+function appliedAtInstant(appliedAt) {
+    if (!/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(appliedAt))
+        return null;
+    const instant = Date.parse(`${appliedAt.replace(" ", "T")}Z`);
+    return Number.isFinite(instant) ? instant : null;
+}
+function runsThisServer(command) {
+    const escapedPath = serverEntrypoint.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const script = new RegExp(`(?:^|\\s|["'])${escapedPath}(?=$|\\s|["'])`).exec(command);
+    if (!script)
+        return false;
+    const executable = command.slice(0, script.index + script[0].indexOf(serverEntrypoint)).trim();
+    return /(?:^|[\\/])node(?:\.exe)?$/.test(executable);
+}
+function canonicalDataDir(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+export function processUsesDataDir(psOutput, dataDir) {
+    if (psOutput.trim() === "")
+        return false;
+    if (!runsThisServer(psOutput))
+        return false;
+    const store = /(?:^|\s)HIVE_DATA_DIR=(.*?)(?=\s+[A-Za-z_][A-Za-z0-9_]*=|$)/.exec(psOutput);
+    const path = store ? store[1].trim() || DEFAULT_DATA_DIR : /(?:^|\s)PATH=/.test(psOutput) ? DEFAULT_DATA_DIR : null;
+    if (path === null)
+        return null;
+    return canonicalDataDir(path) === canonicalDataDir(dataDir);
+}
+export function parseStaleHiveServers(psOutput, appliedAt, observedAt = Date.now()) {
+    const newestMigration = appliedAtInstant(appliedAt);
+    if (newestMigration === null)
+        return { skipped: "the newest migration time is unavailable or invalid" };
+    if (!Number.isFinite(observedAt))
+        return { skipped: "the process snapshot time is invalid" };
+    const rows = [];
+    for (const line of psOutput.split(/\r?\n/)) {
+        if (line.trim() === "")
+            continue;
+        const row = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line);
+        if (!row)
+            return { skipped: "ps returned a row that could not be parsed" };
+        const elapsed = elapsedSeconds(row[3]);
+        if (elapsed === null)
+            return { skipped: "ps returned an invalid elapsed time" };
+        rows.push({ pid: Number(row[1]), ppid: Number(row[2]), elapsed, command: row[4] });
+    }
+    const commands = new Map(rows.map((row) => [row.pid, row.command]));
+    const servers = rows
+        .map((row) => ({ ...row, started: observedAt - row.elapsed * 1000 }))
+        .filter((row) => row.started < newestMigration - STALE_SERVER_BOUNDARY_SLACK_MS && runsThisServer(row.command))
+        .map(({ elapsed: _elapsed, ...row }) => ({
+        ...row,
+        startedAt: new Date(row.started).toISOString(),
+        parentCommand: commands.get(row.ppid) ?? null,
+    }));
+    return { servers };
+}
+export function staleHiveServers(appliedAt, dataDir = DEFAULT_DATA_DIR) {
+    if (appliedAt === null)
+        return { skipped: "the newest migration time is unavailable" };
+    try {
+        const psOutput = execFileSync("ps", ["-eo", "pid=,ppid=,etime=,command="], { encoding: "utf8" });
+        const parsed = parseStaleHiveServers(psOutput, appliedAt, Date.now());
+        if ("skipped" in parsed)
+            return parsed;
+        const servers = [];
+        for (const server of parsed.servers) {
+            const envOutput = execFileSync("ps", ["eww", "-p", String(server.pid), "-o", "command="], {
+                encoding: "utf8",
+            });
+            const sameStore = processUsesDataDir(envOutput, dataDir);
+            if (sameStore === null)
+                return { skipped: "ps returned environment output that could not be parsed" };
+            if (sameStore)
+                servers.push(server);
+        }
+        return { servers };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { skipped: `ps could not be run: ${reason}` };
+    }
+}

package/dist/tmux.js

@@ -184,16 +184,19 @@ function unsetAtSessionScope(name, envFlags) {
         // HIVE_PROJECT_PATH at session scope, silently, for that session's whole life.
     }
 }
+// The pid is read from the creating call because tmux 3.8 reports an empty #{pane_pid} once a pane's
+// process has exited, so a later list-panes can lose the race against a command that dies at once.
+export const CREATED_PANE_FORMAT = "#{pane_id}\t#{session_name}:#{window_id}\t#{pane_pid}";
 export function ensureSession(name, cwd, initial) {
     if (quietTmux("has-session", "-t", `=${name}`))
         return { created: false };
     if (untrustedTmuxServer())
         throw crossServerRefusal("create a tmux session");
     try {
-        const [pane, window] = tmux("new-session", "-d", "-P", "-F", "#{pane_id}\t#{session_name}:#{window_id}", "-s", name, "-c", cwd, ...(initial && "command" in initial ? [...initial.envFlags, initial.command] : [])).split("\t");
+        const [pane, window, pid = ""] = tmux("new-session", "-d", "-P", "-F", CREATED_PANE_FORMAT, "-s", name, "-c", cwd, ...(initial && "command" in initial ? [...initial.envFlags, initial.command] : [])).split("\t");
         if (initial && "command" in initial)
             unsetAtSessionScope(name, initial.envFlags);
-        return { created: true, pane, window };
+        return { created: true, pane, window, pid };
     }
     catch (e) {
         if (!isDuplicateSession(e))
@@ -360,7 +363,7 @@ export function targetLiveProbe(target) {
         const rows = tmux("list-panes", "-t", target, "-F", "#{pane_id} #{pane_pid}")
             .split("\n")
             .map((line) => line.split(" "));
-        const pid = isPaneTarget(target) ? (rows.find(([id]) => id === target)?.[1] ?? null) : null;
+        const pid = isPaneTarget(target) ? (rows.find(([id]) => id === target)?.[1] || null) : null;
         return { live: true, pid };
     }
     catch (e) {
@@ -700,10 +703,10 @@ export function captureFinalScreen(target, lines) {
     }
 }
 export function createWindow(session, windowName, cwd, envFlags, command, projectId, detach = false, retainOnExit = false) {
-    const created = tmux("new-window", ...(detach ? ["-d"] : []), "-P", "-F", "#{pane_id}\t#{session_name}:#{window_id}", "-t", `=${session}`, "-n", windowName, "-c", cwd, ...envFlags, command, ...(retainOnExit ? retainOnExitArgs(`=${session}:${windowName}`) : []));
-    const [pane, window] = created.split("\t");
+    const created = tmux("new-window", ...(detach ? ["-d"] : []), "-P", "-F", CREATED_PANE_FORMAT, "-t", `=${session}`, "-n", windowName, "-c", cwd, ...envFlags, command, ...(retainOnExit ? retainOnExitArgs(`=${session}:${windowName}`) : []));
+    const [pane, window, pid = ""] = created.split("\t");
     configureHiveWindow(window, true, projectId);
-    return { pane, window };
+    return { pane, window, pid };
 }
 function viewSessionChain(session, view) {
     return [

package/dist/tools/agents.js

@@ -18,7 +18,7 @@ import { agentIdentityEnv, branchAt, closeAgentRow, currentOwnership, discardOrp
 import { COMMAND_KIND, runningCommandRow, stopLine, stopProcess, STOP_REASONS } from "../processes.js";
 import { readContextTokens, readContextFill, resolveTranscriptDir } from "../transcript.js";
 import { leadSessionEnded } from "../leadState.js";
-import { capturePane, captureFinalScreen, DEFAULT_LAYOUT, cancelCopyMode, describePaneChoice, ensureAttached, findUnsafeControlChar, holdsHumanInput, liveTargets, observationFailed, observeRowOwnership, ownershipLiveness, paneCurrentCommand, paneInCopyMode, paneWindow, pollPaneReadiness, rowOwnership, sendText, sessionName, setRemainOnExit, sleep, TEXT_ALLOWED_CONTROL_CHARS, tmux, TmuxTimeoutError, WINDOW_LAYOUTS, } from "../tmux.js";
+import { capturePane, captureFinalScreen, DEFAULT_LAYOUT, cancelCopyMode, describePaneChoice, ensureAttached, findUnsafeControlChar, holdsHumanInput, liveTargets, observationFailed, observeRowOwnership, ownershipLiveness, paneCurrentCommand, paneInCopyMode, pollPaneReadiness, rowOwnership, sendText, sessionName, setRemainOnExit, sleep, TEXT_ALLOWED_CONTROL_CHARS, tmux, TmuxTimeoutError, WINDOW_LAYOUTS, } from "../tmux.js";
 import { agentIdParam, agentNameParam, idParam, projectIdParam } from "./params.js";
 import { deriveProvenance, lastLogEvent, lastPermissionMode, reportsAgentStateLog, } from "../stateProvenance.js";
 const CLOSED_ROW_ORDER = "(parked_at != '') DESC, closed_at DESC, id DESC";
@@ -599,48 +599,48 @@ export function registerAgents(server) {
                 rmSync(codexHomeDir(codexHomeKey), { recursive: true, force: true });
             throw e;
         }
-        const { agentId, actorId, target, landedInProjectId, layoutApplied } = spawned;
-        ensureAttached(sessionName());
+        const { agentId, actorId, target, landedInProjectId, layoutApplied, retainedWindow } = spawned;
         let ready = false;
         let dialogTail;
         let exited = false;
         let exitTail;
-        if (harness.classifiesPaneScreen) {
-            const classifier = harness.paneClassifier;
-            // Captured before anything below can kill the pane: remain-on-exit is a WINDOW option,
-            // and the pane id itself stops being addressable once discardOrphanedPane has run.
-            const windowTarget = paneWindow(target) ?? target;
-            try {
-                const outcome = await pollPaneReadiness(target, PANE_READY_MS, classifier.hasInputBox);
-                if (outcome === "gone") {
-                    // remain-on-exit held the pane so its final screen is still readable; capture it,
-                    // persist it onto the row (the pane below is about to be killed), then release it.
-                    // Never run choiceCheck against a retained-but-dead pane: it is frozen content, not
-                    // a live dialog, and choiceCheck's own capture is tuned to read a live screen.
-                    exited = true;
-                    exitTail = captureFinalScreen(target, 30);
-                    db.prepare("UPDATE agents SET exit_tail = ? WHERE id = ?").run(exitTail, agentId);
-                    discardOrphanedPane(target);
-                }
-                else {
-                    const { awaitingChoice, tail } = classifier.choiceCheck(target);
-                    if (awaitingChoice === true) {
-                        dialogTail = tail;
+        try {
+            ensureAttached(sessionName());
+            if (harness.classifiesPaneScreen) {
+                const classifier = harness.paneClassifier;
+                try {
+                    const outcome = await pollPaneReadiness(target, PANE_READY_MS, classifier.hasInputBox);
+                    if (outcome === "gone") {
+                        // remain-on-exit held the pane so its final screen is still readable; capture it,
+                        // persist it onto the row (the pane below is about to be killed), then release it.
+                        // Never run choiceCheck against a retained-but-dead pane: it is frozen content, not
+                        // a live dialog, and choiceCheck's own capture is tuned to read a live screen.
+                        exited = true;
+                        exitTail = captureFinalScreen(target, 30);
+                        db.prepare("UPDATE agents SET exit_tail = ? WHERE id = ?").run(exitTail, agentId);
+                        discardOrphanedPane(target);
                     }
-                    else if (outcome === "ready") {
-                        ready = true;
+                    else {
+                        const { awaitingChoice, tail } = classifier.choiceCheck(target);
+                        if (awaitingChoice === true) {
+                            dialogTail = tail;
+                        }
+                        else if (outcome === "ready") {
+                            ready = true;
+                        }
                     }
                 }
+                catch {
+                    ready = false;
+                }
             }
-            catch {
-                ready = false;
-            }
-            finally {
-                // Unconditional: every early return, throw, or timeout between arming remain-on-exit
-                // and here must still clear it, or the shared window (the default split placement's)
-                // is left silently retaining every later exit in it, not just this one.
-                setRemainOnExit(windowTarget, false);
-            }
+        }
+        finally {
+            // Unconditional: every early return, throw, or timeout between arming remain-on-exit
+            // and here must still clear it, or the shared window (the default split placement's)
+            // is left silently retaining every later exit in it, not just this one.
+            if (retainedWindow)
+                setRemainOnExit(retainedWindow, false);
         }
         const codexInstructions = codexHomeKey ? codexInstructionsPhrase(codexInstructionLayers) : undefined;
         const receipt = {

package/dist/tools/meta.js

@@ -36,6 +36,9 @@ export const ACTOR_OWNER_COLUMNS = [
     ["wakes", "owner"],
     ["wakes", "deliver_actor"],
     ["agent_state_log", "actor_id"],
+    ["questions", "asker"],
+    ["questions", "updated_by"],
+    ["questions", "answered_by"],
 ];
 function actorOwnsRows(actorId) {
     return ACTOR_OWNER_COLUMNS.some(([table, column]) => existsWhere(table, column, actorId));
@@ -139,7 +142,7 @@ export function registerMeta(server) {
         inputSchema: { project_id: idParam },
     }, ({ project_id }) => run(() => selectProjectById(project_id)));
     server.registerTool("project_prune", {
-        description: "Delete every registered project that owns no rows anywhere in the store (pads, todos, kv, leases, agents, wakes, command_trust), verified individually before each delete. Never prunes the caller's own project. With project_id, removes exactly that one project instead of sweeping, and only if it owns no rows; otherwise refuses and names what it owns. With project_id AND confirm_name (the project's exact name), removes that one project even when it owns rows: it takes a snapshot first, refuses while a running row owns a live pane or its pane ownership cannot be verified (agent_close row_only retires the latter), then deletes the project with everything it owns (todos, comments, pads, kv, leases, agents, wakes, trust, agent messages) in one transaction and reports per-table counts and the snapshot path. queen_audit rows naming it are kept, and so are other projects' lead-idle subscriptions that target it, so a watch on its lead ends with a named reason. confirm_name without project_id is refused, and there is no forced sweep. Refuses under HIVE_PROJECT_LOCK=1: this is a whole-store sweep, and a project-locked session may only touch its own project. Immediate, permanent: no dry-run mode.",
+        description: "Delete every registered project that owns no rows anywhere in the store (pads, todos, kv, leases, agents, wakes, command_trust, questions), verified individually before each delete. Never prunes the caller's own project. With project_id, removes exactly that one project instead of sweeping, and only if it owns no rows; otherwise refuses and names what it owns. With project_id AND confirm_name (the project's exact name), removes that one project even when it owns rows: it takes a snapshot first, refuses while a running row owns a live pane or its pane ownership cannot be verified (agent_close row_only retires the latter), then deletes the project with everything it owns (todos, comments, pads, kv, leases, agents, wakes, trust, questions, agent messages) in one transaction and reports per-table counts and the snapshot path. queen_audit rows naming it are kept, and so are other projects' lead-idle subscriptions that target it, so a watch on its lead ends with a named reason. confirm_name without project_id is refused, and there is no forced sweep. Refuses under HIVE_PROJECT_LOCK=1: this is a whole-store sweep, and a project-locked session may only touch its own project. Immediate, permanent: no dry-run mode.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: true,

package/dist/tools/questions.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { currentActor, effectiveProjectId } from "../context.js";
+import { run } from "../result.js";
+import { answerQuestion, askQuestion, getQuestion, listQuestions, updateQuestion, } from "../questions.js";
+import { idParam } from "./params.js";
+const optionParam = z.strictObject({
+    label: z.string().describe("Short choice label; distinct within the question."),
+    description: z.string().describe("What choosing this means."),
+    recommended: z.boolean().describe("Exactly one option is recommended; it is the default."),
+});
+const refParam = z.strictObject({
+    kind: z.enum(["todo", "pr"]),
+    number: idParam.describe("A todo id or PR number. An identifier, not looked up."),
+});
+const stateParam = z.enum(["answered", "defaulted", "pending", "withdrawn"]);
+const noWrites = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+const writes = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+export function registerQuestions(server) {
+    server.registerTool("question_ask", {
+        description: "Record an open question for the human, keyed to this project and to you as the asker. kind=choice takes 2-4 options (each label, description, recommended; exactly one recommended) and a header of 12 characters or fewer; kind=free_text takes just the question and header. Every question carries default_answer: for a choice it is the recommended option's label. Pass ref (a todo id or PR number) to dedupe: asking again with a ref that already has a PENDING question in this project updates that row instead of adding one. The receipt lists other pending questions in this project that look similar (same normalized text, or at least half their longer words shared), so you can question_update one instead. The record is only stored: put the question to the human yourself, in your own turn. You must be a session an answer can be woken back to. When the question is answered, an ordinary wake carrying the answer is queued to you; read the record with question_get.",
+        annotations: writes,
+        inputSchema: {
+            kind: z.enum(["choice", "free_text"]),
+            question: z.string(),
+            header: z.string().describe("12 characters or fewer."),
+            options: z.array(optionParam).optional().describe("Required for choice, forbidden for free_text."),
+            default_answer: z.string().describe("What you do if unanswered. For a choice, the recommended label."),
+            ref: refParam.optional(),
+        },
+        outputSchema: {
+            question_id: idParam,
+            created: z.boolean(),
+            similar_question_ids: z.array(idParam),
+        },
+    }, (args) => run(() => {
+        const projectId = effectiveProjectId();
+        const input = {
+            kind: args.kind,
+            question: args.question,
+            header: args.header,
+            default_answer: args.default_answer,
+            ...(args.options !== undefined ? { options: args.options } : {}),
+            ...(args.ref !== undefined ? { ref: args.ref } : {}),
+        };
+        return askQuestion(projectId, currentActor(), input);
+    }));
+    server.registerTool("question_get", {
+        description: "Read one question in this project by id, in any state, with its answer and notes once answered.",
+        annotations: noWrites,
+        inputSchema: { question_id: idParam },
+    }, (args) => run(() => getQuestion(effectiveProjectId(), args.question_id)));
+    server.registerTool("question_list", {
+        description: "List this project's pending questions, then its defaulted ones (acted on by default, still open to reversal), oldest first within each group. Answered and withdrawn questions are not listed; read one by id with question_get.",
+        annotations: noWrites,
+        inputSchema: {},
+    }, () => run(() => ({ questions: listQuestions(effectiveProjectId()) })));
+    server.registerTool("question_update", {
+        description: "Edit a pending question's text (question, header, options, default_answer; the whole result is revalidated) or move it out of pending with state=defaulted (you acted on your default) or state=withdrawn (moot). A defaulted question can still be withdrawn. Moving state needs the asking session or the human; an answered or withdrawn question cannot be changed. The ref, asker and wake target never change.",
+        annotations: writes,
+        inputSchema: {
+            question_id: idParam,
+            question: z.string().optional(),
+            header: z.string().optional(),
+            options: z.array(optionParam).optional(),
+            default_answer: z.string().optional(),
+            state: z.enum(["defaulted", "withdrawn"]).optional(),
+        },
+        outputSchema: { question_id: idParam, state: stateParam },
+    }, (args) => run(() => {
+        const { question_id, ...patch } = args;
+        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.",
+        annotations: writes,
+        inputSchema: {
+            question_id: idParam,
+            answer: z.string(),
+            notes: z.string().optional(),
+        },
+        outputSchema: {
+            question_id: idParam,
+            wake_id: idParam.nullable(),
+            wake_skipped: z.string().optional(),
+        },
+    }, (args) => run(() => answerQuestion(effectiveProjectId(), currentActor(), args.question_id, args.answer, args.notes)));
+}

package/dist/tools/wakes.js

@@ -35,7 +35,7 @@ function refuseUnclassifiableTarget(agent) {
         "error you can read now. Drive this pane with agent_send(keys: [...]) instead, which is unguarded for " +
         "exactly this reason.");
 }
-function resolveDelivery(projectId, deliverTo) {
+export function resolveWakeDelivery(projectId, deliverTo) {
     if (deliverTo != null) {
         const agent = resolveAgentRef(projectId, deliverTo);
         // Before the liveness probe: the harness is a durable fact about the row, while liveness is a
@@ -130,7 +130,7 @@ function deliveredByNote(t) {
         : null;
 }
 export const truncateBody = (body) => body.length > 120 ? `${cutToUnitBudget(body, 120)}…` : body;
-function rejectUnsafeBody(body) {
+export function assertSafeWakeBody(body) {
     const bad = findUnsafeControlChar(body, TEXT_ALLOWED_CONTROL_CHARS);
     if (bad) {
         throw new Error(`body cannot contain ${bad.label} at offset ${bad.index}: it is typed literally into the target pane ` +
@@ -173,7 +173,7 @@ const openStandingWatch = db.transaction((projectId, owner, body, deliverActor,
     return row;
 });
 function createStandingWatch(projectId, args) {
-    const delivery = resolveDelivery(projectId, args.deliver_to);
+    const delivery = resolveWakeDelivery(projectId, args.deliver_to);
     const maxWait = args.max_wait_seconds ?? STANDING_WATCH_LIFETIME_SECONDS;
     const row = openStandingWatch.immediate(projectId, currentActor(), args.body, delivery.actor, delivery.pane, maxWait);
     const crew = db
@@ -261,7 +261,7 @@ function createLeadWatch(leadProjectId, args) {
             note: `Project ${leadProjectId}'s lead has already ended its turn; nothing was scheduled. Read it now.`,
         };
     }
-    const delivery = resolveDelivery(home);
+    const delivery = resolveWakeDelivery(home);
     const maxWait = args.max_wait_seconds ?? 900;
     const row = openLeadWatch.immediate(home, args.body, mode, delivery, maxWait, {
         projectId: leadProjectId,
@@ -329,9 +329,9 @@ export function registerWakes(server) {
             repeating: z.boolean(),
         },
     }, (args) => run(() => {
-        rejectUnsafeBody(args.body);
+        assertSafeWakeBody(args.body);
         const projectId = effectiveProjectId(args.project_id);
-        const delivery = resolveDelivery(projectId, args.deliver_to);
+        const delivery = resolveWakeDelivery(projectId, args.deliver_to);
         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)
@@ -407,7 +407,7 @@ export function registerWakes(server) {
             note: z.string().optional(),
         },
     }, (args) => run(() => {
-        rejectUnsafeBody(args.body);
+        assertSafeWakeBody(args.body);
         const projectId = effectiveProjectId(args.project_id);
         const selectors = [
             args.agents != null && "agents",
@@ -441,7 +441,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 = resolveDelivery(projectId, args.deliver_to);
+        const delivery = resolveWakeDelivery(projectId, args.deliver_to);
         const snapshot = liveTargets();
         if (mode === "all") {
             const allIdle = watched.every((a) => {
@@ -577,7 +577,7 @@ export function registerWakes(server) {
         const sets = [];
         const params = [];
         if (args.body != null) {
-            rejectUnsafeBody(args.body);
+            assertSafeWakeBody(args.body);
             sets.push("body = ?");
             params.push(args.body);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmgmyr/hive",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "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": {