@cmgmyr/hive 1.9.0 → 1.9.1

package/README.md

@@ -5,7 +5,7 @@ Run a crew of Claude Code and Codex workers from one lead session: visible tmux
 
 - Visible workers: each one is a real tmux pane you can read and type into.
 - Exact state: workers report it through their own CLI's hooks, so nothing polls.
-- One local SQLite store: no daemon, and nothing leaves your machine.
+- One local SQLite store: no daemon. The MCP server, hooks, and scheduler make no outbound requests; the CLI contacts npm only to check for updates, and upgrades can download ([details](docs/security.md)).
 
 ![hive: a lead plans, spawns workers, and is woken when they finish](https://raw.githubusercontent.com/cmgmyr/hive/main/docs/assets/demo.svg)
 
@@ -32,7 +32,7 @@ Run `cd ~/Code/your-project && hive`. It is shorthand for `hive lead`, and it op
 
 ## How it works
 
-Each Claude Code session runs its own `hive` MCP server over stdio, and every instance reads and writes one SQLite database (WAL mode) at `~/.hive/hive.db`, so every session sees the same state. There is no daemon and nothing leaves your machine. State is scoped to a project (a directory), resolved from the working directory; a lead spawns workers into tmux panes locked to that project.
+Each Claude Code session runs its own `hive` MCP server over stdio, and every instance reads and writes one SQLite database (WAL mode) at `~/.hive/hive.db`, so every session sees the same state. There is no daemon. The MCP server, hooks, and scheduler make no outbound requests; the CLI contacts npm only to check for updates, and upgrades can download ([details](docs/security.md)). State is scoped to a project (a directory), resolved from the working directory; a lead spawns workers into tmux panes locked to that project.
 
 ## Why not subagents?
 

package/dist/build-info.json

@@ -1 +1 @@
-{"version":"1.9.0","sha":"b0be61b","dirty":false,"build_id":"b0c86484d75006efe978e316cdbccb3c9b4e09604634cfff5f7a61c8b8d825b0"}
+{"version":"1.9.1","sha":"2056b89","dirty":false,"build_id":"6b9bbe7ee1cda1fc2700518664c980aac9692d27caead18970553a3f6b3cbae9"}

package/dist/cli.js

@@ -745,7 +745,7 @@ const HIVE_YML_TEMPLATE = `# hive project config. Read by \`hive lead\` from the
 
 # dashboard: true               # write .hive/dashboard.html (default: false)
 
-# quiet_messaging: true        # wakes reach a claude lead as one row (default: false; restart the lead)
+# quiet_messaging: true        # wakes and worker messages reach a claude lead as one row (default: false; restart the lead)
 
 # vars:                         # substituted into the profile runbook
 #   repo: owner/name            # {{repo}}
@@ -3376,7 +3376,7 @@ function cmdPad(argv) {
     process.stdout.write(withTrailingNewline(pad.content));
 }
 process.stdout.on("error", (error) => {
-    if (error.code === "EPIPE")
+    if (error.code === "EPIPE" || error.code === "ENOTCONN")
         process.exit(0);
     throw error;
 });

package/dist/db.js

@@ -415,6 +415,19 @@ ALTER TABLE agents ADD COLUMN claude_messaging_pane_pid TEXT NOT NULL DEFAULT ''
 ALTER TABLE wakes ADD COLUMN delivery_method TEXT;
 ALTER TABLE wakes ADD COLUMN socket_attempt_at TEXT;
 ALTER TABLE wakes ADD COLUMN socket_delivery_note TEXT;
+`,
+    `ALTER TABLE wakes ADD COLUMN delivered_by TEXT;`,
+    `
+ALTER TABLE agent_messages ADD COLUMN delivery_status TEXT;
+ALTER TABLE agent_messages ADD COLUMN delivery_method TEXT;
+ALTER TABLE agent_messages ADD COLUMN socket_attempt_at TEXT;
+ALTER TABLE agent_messages ADD COLUMN confirmed_at TEXT;
+ALTER TABLE agent_messages ADD COLUMN fallback_claimed_at TEXT;
+ALTER TABLE agent_messages ADD COLUMN typed_at TEXT;
+ALTER TABLE agent_messages ADD COLUMN delivery_note TEXT;
+ALTER TABLE agent_messages ADD COLUMN target_identity TEXT;
+ALTER TABLE agent_messages ADD COLUMN sender_tag TEXT;
+CREATE INDEX idx_agent_messages_delivery ON agent_messages(delivery_status, id) WHERE delivery_status IS NOT NULL;
 `,
 ];
 export function storeSchemaAhead(database) {

package/dist/harnesses.js

@@ -1,4 +1,4 @@
-import { claudeTrailerView, codexInputBoxState, codexTrailerView, codexPaneChoiceCheck, codexPaneHasInputBox, inputBoxState, paneChoiceCheck, paneHasInputBox, } from "./tmux.js";
+import { claudeTrailerView, codexInputBoxState, codexTrailerView, codexPaneChoiceCheck, codexPaneHasInputBox, inputBoxSnapshot, inputBoxState, paneChoiceCheck, paneHasInputBox, } from "./tmux.js";
 export function commandHead(command) {
     return command.trim().split(/\s+/)[0] ?? "";
 }
@@ -52,7 +52,7 @@ const claudeHarness = {
     supportsResume: true,
     supportsRename: true,
     classifiesPaneScreen: true,
-    paneClassifier: { choiceCheck: paneChoiceCheck, inputBoxState, hasInputBox: paneHasInputBox, trailerView: claudeTrailerView },
+    paneClassifier: { choiceCheck: paneChoiceCheck, inputBoxState, inputBoxSnapshot, hasInputBox: paneHasInputBox, trailerView: claudeTrailerView },
     hasScopes: true,
     needsHome: false,
     // "--" so a message that starts with a dash is never read as a flag.

package/dist/help.js

@@ -148,9 +148,13 @@ runbook (fork it first), not a pad write.`,
     Text is prefixed with the sender tag.
     Text over 300 chars sent to a LEAD by anyone but that lead is stored and
     delivered as a one-line pointer, so the human's own pane stays readable;
-    the receipt says shortened and names the message id.
-  agent_message_get(message_id) — the full text behind a pointer line. Kept
-    7 days; a lookup for a pruned id says it expired, not that it is missing.
+    the receipt says shortened and names the message id. With quiet_messaging
+    on, a worker's submitted text to a Claude lead is stored with an id and
+    posted to the lead's messaging socket instead; the receipt says pending
+    until the lead's prompt confirms it, and hive types it into the pane once
+    if nothing does. Do not resend a pending send.
+  agent_message_get(message_id) — the full text behind a pointer line, plus
+    the delivery state of a quiet message. Kept 7 days; a lookup for a pruned id says it expired, not that it is missing.
   agent_output(name|agent_id, lines?) — read the rendered terminal.
   agent_status(name|agent_id, include_brief?) — liveness, current command,
     short tail, and the path to the brief this worker was given

package/dist/leadMessage.js

@@ -14,6 +14,17 @@ export const MESSAGE_RETENTION = "-7 days";
 // direction. Far above any observed rate, and lower than agent_state_log's 20,000 because a row here
 // holds unbounded message text rather than a hook payload.
 export const MESSAGE_MAX_ROWS = 5_000;
+export const DELIVERY_FIELDS = [
+    "delivery_status",
+    "delivery_method",
+    "socket_attempt_at",
+    "confirmed_at",
+    "fallback_claimed_at",
+    "typed_at",
+    "delivery_note",
+    "target_identity",
+    "sender_tag",
+];
 function senderName(projectId, actorId) {
     const row = db
         .prepare(`SELECT name FROM agents WHERE project_id = ? AND actor_id = ?
@@ -44,7 +55,7 @@ export function storeLeadMessage(projectId, fromActor, toAgentId, text) {
 }
 export function readLeadMessage(projectId, messageId) {
     return db
-        .prepare(`SELECT id, from_actor, from_name, to_agent_id, text, created_at
+        .prepare(`SELECT id, from_actor, from_name, to_agent_id, text, created_at, ${DELIVERY_FIELDS.join(", ")}
          FROM agent_messages WHERE id = ? AND project_id = ?`)
         .get(messageId, projectId);
 }
@@ -75,17 +86,27 @@ export function missMessage(messageId, kind) {
 // also covers format characters. The head comes from outside, and a raw control byte in it reaches tmux
 // as a keystroke rather than as text, submitting this pointer early and splitting it. The sender's name
 // is flattened by senderTag when it builds the tag ahead of this marker - the tag is who, this is what.
-export function leadPointerMarker(id, text) {
-    return `[message #${id}, ${text.length} chars]`;
+export function leadPointerMarker(id, text, redelivered = false) {
+    return `[message #${id}, ${text.length} chars${redelivered ? ", re-delivered" : ""}]`;
 }
-export function renderLeadPointer(id, text, tag) {
+const redeliveredLead = (id, redelivered) => redelivered ? ` If you already handled message #${id}, ignore this.` : "";
+export function renderLeadPointer(id, text, tag, redelivered = false) {
     const flat = flatten(text);
     const head = flat.length > HEAD_BUDGET ? cutToUnitBudget(flat, HEAD_BUDGET) + ELLIPSIS : flat;
-    return `${tag}${leadPointerMarker(id, text)} ${head} agent_message_get(${id}) for the full text.`;
+    return `${tag}${leadPointerMarker(id, text, redelivered)}${redeliveredLead(id, redelivered)} ${head} agent_message_get(${id}) for the full text.`;
 }
-export function shortenedSendNote(id, deliveredChars) {
-    return (`Over ${LEAD_MESSAGE_THRESHOLD} characters to a LEAD, so that pane got a ${deliveredChars}-character ` +
-        `pointer instead of this text: a lead's pane is a human's own window and hive keeps it quiet. Nothing ` +
+// A short message carries its id too, so a quiet send has a marker its confirmation can match.
+export function renderLeadMessage(id, text, tag, redelivered = false) {
+    return text.length > LEAD_MESSAGE_THRESHOLD
+        ? renderLeadPointer(id, text, tag, redelivered)
+        : `${tag}${leadPointerMarker(id, text, redelivered)}${redeliveredLead(id, redelivered)} ${text}`;
+}
+export function shortenedSendNote(id, deliveredChars, channel = "pane") {
+    return (`Over ${LEAD_MESSAGE_THRESHOLD} characters to a LEAD, so ` +
+        (channel === "pane"
+            ? `that pane got a ${deliveredChars}-character pointer instead of this text`
+            : `hive delivers a ${deliveredChars}-character pointer instead of this text, over the lead's messaging socket or, failing that, typed once into its pane`) +
+        `: a lead's pane is a human's own window and hive keeps it quiet. Nothing ` +
         `was lost - the full text is stored as message ${id} and the pointer names agent_message_get(${id}) - ` +
         `but the lead reads the rest only if it chooses to. Put whatever must be ACTED on in the first ` +
         `${HEAD_BUDGET} characters, or on the todo, where it is durable. Worker-bound sends are never shortened.`);

package/dist/leadMessageDelivery.js

@@ -0,0 +1,379 @@
+import { join } from "node:path";
+import { dataDir, db } from "./db.js";
+import { CROSS_SESSION_CLOSE, postClaudeWake, senderAddress } from "./claudeWake.js";
+import { harnessFor, paneClassifierFor } from "./harnesses.js";
+import { LEAD_MESSAGE_THRESHOLD, renderLeadMessage, senderTag, shortenedSendNote, storeLeadMessage, } from "./leadMessage.js";
+import { readLeadTurnState } from "./leadState.js";
+import { loadProjectYml } from "./projectYml.js";
+import { currentOwnership, PaneOwnershipLost, paneIdentity, requireStillOwned } from "./spawn.js";
+import { holdsHumanInput, paneInCopyMode, sendText, sleep, TmuxTimeoutError, } from "./tmux.js";
+export const SOCKET_MESSAGE_FOOTER = "Automated hive worker message. Do not reply to this socket sender.";
+export const MESSAGE_STATUS = {
+    socketPending: "socket-pending",
+    fallbackPending: "fallback-pending",
+    fallbackClaimed: "fallback-claimed",
+    complete: "complete",
+    failed: "failed",
+};
+export const MESSAGE_METHOD = {
+    socket: "socket",
+    pty: "pty",
+    ptyAfterSocketTimeout: "pty-after-socket-timeout",
+};
+const PANE_LEASE_TTL_SECONDS = 6;
+const PANE_LEASE_SETTLE_MS = 500;
+const CONFIRM_GRACE_SECONDS = 60;
+const ENVELOPE_OPEN = '<cross-session-message from="';
+const ENVELOPE_SENDER_CLOSE = '" from-name="hive">';
+const EV_PROMPT = "(CASE WHEN json_valid(ev.payload) THEN COALESCE(json_extract(ev.payload, '$.prompt'), '') ELSE ev.payload END)";
+const EV_MARKER = "(agent_messages.sender_tag || '[message #' || agent_messages.id || ',')";
+const EV_HEADER_END = `instr(${EV_PROMPT}, char(10))`;
+// The exact "[hive:worker NAME] [message #N," at prompt offset 0 (typed) or opening hive's own envelope body (socket).
+const messageEvidenceSql = (select) => `
+  SELECT ${select} FROM agent_state_log ev
+   WHERE ev.actor_id = (SELECT a.actor_id FROM agents a WHERE a.id = agent_messages.to_agent_id)
+     AND ev.event = 'prompt'
+     AND ev.created_at >= COALESCE(agent_messages.socket_attempt_at, agent_messages.created_at)
+     AND (substr(${EV_PROMPT}, 1, length(${EV_MARKER})) = ${EV_MARKER}
+          OR (${EV_HEADER_END} > ${ENVELOPE_OPEN.length + ENVELOPE_SENDER_CLOSE.length}
+              AND substr(${EV_PROMPT}, 1, ${ENVELOPE_OPEN.length}) = '${ENVELOPE_OPEN}'
+              AND substr(${EV_PROMPT}, ${EV_HEADER_END} - ${ENVELOPE_SENDER_CLOSE.length}, ${ENVELOPE_SENDER_CLOSE.length}) = '${ENVELOPE_SENDER_CLOSE}'
+              AND instr(substr(${EV_PROMPT}, ${ENVELOPE_OPEN.length + 1}, ${EV_HEADER_END} - ${ENVELOPE_OPEN.length + ENVELOPE_SENDER_CLOSE.length + 1}), '"') = 0
+              AND substr(${EV_PROMPT}, ${EV_HEADER_END} + 1, length(${EV_MARKER})) = ${EV_MARKER}
+              AND instr(${EV_PROMPT}, char(10) || '${CROSS_SESSION_CLOSE}') > ${EV_HEADER_END}))`;
+const RETAINED = "agent_messages.created_at >= datetime('now', '-7 days')";
+function quietMessagingOn(projectId) {
+    const project = db.prepare("SELECT path FROM projects WHERE id = ?").get(projectId);
+    return project !== undefined && loadProjectYml(project.path).config?.quiet_messaging === true;
+}
+function eligible(options) {
+    const { projectId, fromActor, target, submit } = options;
+    if (!submit || target.kind !== "lead" || target.status !== "running" || target.actor_id === fromActor)
+        return false;
+    if (harnessFor(target.command).name !== "claude")
+        return false;
+    const sender = db
+        .prepare("SELECT 1 AS hit FROM agents WHERE project_id = ? AND actor_id = ? AND status = 'running' AND kind = 'agent'")
+        .get(projectId, fromActor);
+    return sender !== undefined && quietMessagingOn(projectId);
+}
+function registeredSocket(target) {
+    return (target.claude_messaging_socket !== "" &&
+        target.claude_messaging_pane_pid !== "" &&
+        target.claude_messaging_pane_pid === target.pane_pid);
+}
+function leadSession(agentId, panePid) {
+    const turn = readLeadTurnState(agentId);
+    return turn !== null && turn.pane_pid === panePid ? turn.session_id : "";
+}
+function readRow(id) {
+    return db.prepare("SELECT * FROM agent_messages WHERE id = ?").get(id);
+}
+function setStatus(id, from, to, fields = {}) {
+    const names = Object.keys(fields);
+    const sets = ["delivery_status = ?", ...names.map((n) => `${n} = ?`)].join(", ");
+    try {
+        return (db
+            .prepare(`UPDATE agent_messages SET ${sets} WHERE id = ? AND delivery_status = ?`)
+            .run(to, ...names.map((n) => fields[n]), id, from).changes === 1);
+    }
+    catch {
+        return false;
+    }
+}
+const NOW = "strftime('%Y-%m-%d %H:%M:%f', 'now')";
+function stamp(id, column) {
+    try {
+        db.prepare(`UPDATE agent_messages SET ${column} = ${NOW} WHERE id = ?`).run(id);
+    }
+    catch {
+    }
+}
+function socketText(id, text, tag) {
+    return `${renderLeadMessage(id, text, tag)}\n\n${SOCKET_MESSAGE_FOOTER}`;
+}
+function acquirePaneLease(row, key) {
+    try {
+        db.prepare("INSERT OR IGNORE INTO actors (id, name, kind) VALUES (?, ?, 'agent')").run(row.from_actor, row.from_name);
+        db.prepare("DELETE FROM leases WHERE project_id = ? AND lock_key = ? AND expires_at < datetime('now')").run(row.project_id, key);
+        const held = db
+            .prepare(`INSERT INTO leases (project_id, lock_key, owner, expires_at)
+         VALUES (?, ?, ?, datetime('now', printf('+%d seconds', ?)))
+         ON CONFLICT(project_id, lock_key) DO NOTHING
+         RETURNING expires_at`)
+            .get(row.project_id, key, row.from_actor, PANE_LEASE_TTL_SECONDS);
+        return held?.expires_at ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function releasePaneLease(row, key, expiresAt) {
+    try {
+        db.prepare("DELETE FROM leases WHERE project_id = ? AND lock_key = ? AND expires_at = ?").run(row.project_id, key, expiresAt);
+    }
+    catch {
+    }
+}
+function hold(row, reason) {
+    try {
+        db.prepare("UPDATE agent_messages SET delivery_note = ? WHERE id = ? AND delivery_status = ?").run(reason, row.id, MESSAGE_STATUS.fallbackPending);
+    }
+    catch {
+    }
+    return { kind: "held", reason };
+}
+function failPending(row, reason) {
+    setStatus(row.id, MESSAGE_STATUS.fallbackPending, MESSAGE_STATUS.failed, { delivery_note: reason });
+    return { kind: "failed", reason };
+}
+function pasteFailure(err, pasted, buffered) {
+    const why = err instanceof Error ? err.message : String(err);
+    if (pasted) {
+        return err instanceof PaneOwnershipLost
+            ? `pasted, then the Enter was withheld because pane ownership was lost: ${why} The text may be on screen unsubmitted.`
+            : `pasted, then the Enter failed: ${why} The text is on screen unsubmitted.`;
+    }
+    if (buffered && err instanceof TmuxTimeoutError)
+        return `the paste timed out, so the text MAY be on screen unsubmitted: ${why}`;
+    return `nothing was pasted: ${why}`;
+}
+// One guarded pane attempt. The claim is the CAS that makes it at most one per message.
+async function paneFallback(row, snapshot) {
+    let identity;
+    try {
+        identity = paneIdentity(JSON.parse(row.target_identity ?? ""));
+    }
+    catch {
+        return failPending(row, "the accepted target identity is unreadable, so no pane can be certified as the lead's");
+    }
+    const target = db.prepare("SELECT kind, command FROM agents WHERE id = ?").get(row.to_agent_id);
+    const ownership = currentOwnership(row.to_agent_id, identity, snapshot);
+    if (ownership === "unknown")
+        return hold(row, "the lead's pane ownership reads unknown");
+    if (ownership !== "live" || target === undefined) {
+        return failPending(row, `the lead pane this message was accepted for is ${ownership}; nothing is typed into a replacement`);
+    }
+    const key = `wake-pane:${identity.tmux_socket}:${identity.tmux_target}`;
+    const expiresAt = acquirePaneLease(row, key);
+    if (expiresAt === null)
+        return hold(row, "another delivery holds the lead's pane");
+    let wrote = false;
+    try {
+        const pane = identity.tmux_target;
+        if (paneInCopyMode(pane) === true)
+            return hold(row, "the lead's pane is in copy mode");
+        const classifier = paneClassifierFor(target.command);
+        if (!classifier)
+            return hold(row, "hive cannot classify the lead's screen");
+        const choice = classifier.choiceCheck(pane).awaitingChoice;
+        if (choice !== false)
+            return hold(row, choice ? "the lead's pane is waiting on a choice" : "the lead's pane could not be read");
+        if (holdsHumanInput(classifier.inputBoxState(pane)))
+            return hold(row, "the lead's input box holds unsubmitted text");
+        const claimed = (() => {
+            try {
+                return (db
+                    .prepare(`UPDATE agent_messages SET delivery_status = ?, fallback_claimed_at = ${NOW}
+                WHERE id = ? AND delivery_status = ? AND NOT EXISTS (${messageEvidenceSql("1")})`)
+                    .run(MESSAGE_STATUS.fallbackClaimed, row.id, MESSAGE_STATUS.fallbackPending).changes === 1);
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (!claimed)
+            return { kind: "settled" };
+        let pasted = false;
+        let buffered = false;
+        wrote = true;
+        try {
+            await sendText(pane, renderLeadMessage(row.id, row.text, row.sender_tag ?? "", row.socket_attempt_at !== null), true, () => {
+                pasted = true;
+                stamp(row.id, "typed_at");
+            }, () => {
+                buffered = true;
+            }, () => requireStillOwned(row.to_agent_id, identity, `message #${row.id} fallback`));
+        }
+        catch (err) {
+            const reason = pasteFailure(err, pasted, buffered);
+            setStatus(row.id, MESSAGE_STATUS.fallbackClaimed, MESSAGE_STATUS.failed, { delivery_note: reason });
+            return { kind: "failed", reason };
+        }
+        setStatus(row.id, MESSAGE_STATUS.fallbackClaimed, MESSAGE_STATUS.complete);
+        return { kind: "typed" };
+    }
+    finally {
+        if (wrote)
+            await sleep(PANE_LEASE_SETTLE_MS);
+        releasePaneLease(row, key, expiresAt);
+    }
+}
+function earlierFallbackPending(row) {
+    return (db
+        .prepare(`SELECT 1 AS hit FROM agent_messages
+          WHERE from_actor = ? AND to_agent_id = ? AND id < ? AND delivery_status = ? AND ${RETAINED}`)
+        .get(row.from_actor, row.to_agent_id, row.id, MESSAGE_STATUS.fallbackPending) !== undefined);
+}
+const DO_NOT_RESEND = "do not resend";
+// null means this send is not eligible, and agent_send's ordinary pane path runs unchanged.
+export async function sendQuietLeadMessage(options) {
+    if (!eligible(options))
+        return null;
+    const { projectId, fromActor, target, text } = options;
+    const identity = paneIdentity(target);
+    const tag = senderTag(projectId, fromActor);
+    const session = leadSession(target.id, target.pane_pid);
+    const { id } = storeLeadMessage(projectId, fromActor, target.id, text);
+    const long = text.length > LEAD_MESSAGE_THRESHOLD;
+    const base = { agent_id: target.id, name: target.name, message_id: id, ...(long ? { shortened: true } : {}) };
+    const shortNote = (channel, redelivered = false) => long ? ` ${shortenedSendNote(id, renderLeadMessage(id, text, tag, redelivered).length, channel)}` : "";
+    const body = socketText(id, text, tag);
+    const skip = !registeredSocket(target)
+        ? "no messaging socket registered for this lead pane"
+        : body.includes(CROSS_SESSION_CLOSE)
+            ? "the text contains the envelope's closing tag"
+            : null;
+    // One statement makes the row visible to the scheduler, already in its route's status.
+    db.prepare(`UPDATE agent_messages SET delivery_status = ?, delivery_method = ?, socket_attempt_at = ${skip === null ? NOW : "NULL"},
+       delivery_note = ?, target_identity = ?, sender_tag = ? WHERE id = ?`).run(skip === null ? MESSAGE_STATUS.socketPending : MESSAGE_STATUS.fallbackPending, skip === null ? MESSAGE_METHOD.socket : MESSAGE_METHOD.pty, skip, JSON.stringify(identity), tag, id);
+    if (skip === null) {
+        const posted = await postClaudeWake({
+            socketPath: target.claude_messaging_socket,
+            senderAddress: senderAddress(join(dataDir, "wake-sender.sock")),
+            text: body,
+            beforeWrite: () => {
+                requireStillOwned(target.id, identity, `message #${id} socket delivery`);
+                const now = db
+                    .prepare(`SELECT a.status, a.kind, a.pane_pid, a.claude_messaging_socket AS socket, a.claude_messaging_pane_pid AS pid,
+                    m.delivery_status
+               FROM agents a, agent_messages m WHERE a.id = ? AND m.id = ?`)
+                    .get(target.id, id);
+                return (now !== undefined &&
+                    now.status === "running" &&
+                    now.kind === "lead" &&
+                    now.socket === target.claude_messaging_socket &&
+                    now.pid === identity.pane_pid &&
+                    now.pane_pid === identity.pane_pid &&
+                    now.delivery_status === MESSAGE_STATUS.socketPending &&
+                    leadSession(target.id, identity.pane_pid) === session);
+            },
+        });
+        if (posted) {
+            return {
+                ...base,
+                sent: true,
+                pending: true,
+                delivery_method: MESSAGE_METHOD.socket,
+                confirmed: false,
+                note: `Posted locally to the lead's messaging socket as message #${id}, awaiting prompt confirmation; ${DO_NOT_RESEND}. ` +
+                    "sent means handed to the transport, not read: if no prompt confirms it, hive types it into the lead's pane once." +
+                    shortNote("socket"),
+            };
+        }
+        setStatus(id, MESSAGE_STATUS.socketPending, MESSAGE_STATUS.fallbackPending, {
+            delivery_method: MESSAGE_METHOD.ptyAfterSocketTimeout,
+            delivery_note: "the socket post failed or timed out",
+        });
+    }
+    const row = readRow(id);
+    const method = (row.delivery_method ?? MESSAGE_METHOD.pty);
+    const outcome = earlierFallbackPending(row)
+        ? hold(row, "an earlier message from this sender to this lead is still awaiting its pane fallback, and this one follows it")
+        : await paneFallback(row);
+    if (outcome.kind === "typed") {
+        const note = shortNote("pane", row.socket_attempt_at !== null).trim();
+        return { ...base, sent: true, pending: false, delivery_method: method, ...(note ? { note } : {}) };
+    }
+    if (outcome.kind === "held") {
+        return {
+            ...base,
+            sent: false,
+            pending: true,
+            delivery_method: method,
+            note: `Not typed yet: ${outcome.reason}. Message #${id} is accepted and stored, and hive retries it from the ` +
+                `scheduler; do NOT resubmit it. agent_message_get(${id}) shows its delivery state.` +
+                shortNote("socket"),
+        };
+    }
+    if (outcome.kind === "settled") {
+        const now = readRow(id);
+        return {
+            ...base,
+            sent: true,
+            pending: now?.delivery_status !== MESSAGE_STATUS.complete,
+            delivery_method: method,
+            confirmed: now?.confirmed_at != null,
+            note: `Message #${id} was settled by another delivery path; ${DO_NOT_RESEND}. agent_message_get(${id}) shows its state.`,
+        };
+    }
+    throw new Error(`[agent_send:quiet-fallback-failed] message #${id} to ${target.name}: ${outcome.reason} hive will not type it again. ` +
+        `Do NOT resend blindly: read the lead's pane first, and agent_message_get(${id}) shows the recorded state.`);
+}
+function graceExpired(row, actorId, panePid) {
+    const firstStop = db
+        .prepare("SELECT MIN(created_at) AS t FROM agent_state_log WHERE actor_id = ? AND event = 'stop' AND created_at >= ?")
+        .get(actorId, row.socket_attempt_at).t;
+    let from = firstStop;
+    if (from === null) {
+        const turn = readLeadTurnState(row.to_agent_id);
+        if (turn !== null && turn.state === "working" && turn.pane_pid === panePid)
+            return false;
+        from = row.socket_attempt_at;
+    }
+    return db.prepare("SELECT (julianday('now') - julianday(?)) * 86400 >= ? AS due").get(from, CONFIRM_GRACE_SECONDS).due === 1;
+}
+function confirmFromPrompts() {
+    db.prepare(`UPDATE agent_messages SET confirmed_at = (${messageEvidenceSql("MIN(ev.created_at)")}), delivery_status = ?
+      WHERE delivery_status IS NOT NULL AND delivery_status != ? AND confirmed_at IS NULL AND ${RETAINED}
+        AND EXISTS (${messageEvidenceSql("1")})`).run(MESSAGE_STATUS.complete, MESSAGE_STATUS.complete);
+}
+function expireGrace() {
+    const pending = db
+        .prepare(`SELECT agent_messages.* FROM agent_messages WHERE delivery_status = ? AND ${RETAINED} ORDER BY id`)
+        .all(MESSAGE_STATUS.socketPending);
+    for (const row of pending) {
+        try {
+            const target = db.prepare("SELECT actor_id FROM agents WHERE id = ?").get(row.to_agent_id);
+            const panePid = JSON.parse(row.target_identity ?? "{}").pane_pid ?? "";
+            if (target === undefined || !graceExpired(row, target.actor_id, panePid))
+                continue;
+            db.prepare(`UPDATE agent_messages SET delivery_status = ?, delivery_method = ?, delivery_note = ?
+          WHERE id = ? AND delivery_status = ? AND NOT EXISTS (${messageEvidenceSql("1")})`).run(MESSAGE_STATUS.fallbackPending, MESSAGE_METHOD.ptyAfterSocketTimeout, "no prompt confirmed the socket post within its grace", row.id, MESSAGE_STATUS.socketPending);
+        }
+        catch {
+        }
+    }
+}
+// Runs inside tick's try; each row's failure is contained so one bad delivery cannot strand the rest.
+export async function retryQuietLeadMessages(snapshot) {
+    try {
+        confirmFromPrompts();
+    }
+    catch {
+    }
+    expireGrace();
+    let due;
+    try {
+        due = db
+            .prepare(`SELECT agent_messages.* FROM agent_messages WHERE delivery_status = ? AND ${RETAINED} ORDER BY id`)
+            .all(MESSAGE_STATUS.fallbackPending);
+    }
+    catch {
+        return;
+    }
+    const blocked = new Set();
+    for (const row of due) {
+        const pair = `${row.from_actor}\u0000${row.to_agent_id}`;
+        if (blocked.has(pair))
+            continue;
+        try {
+            const outcome = await paneFallback(row, snapshot);
+            if (outcome.kind === "held")
+                blocked.add(pair);
+        }
+        catch {
+            blocked.add(pair);
+        }
+    }
+}

package/dist/scheduler.js

@@ -1,5 +1,5 @@
 import { QUEEN_AUDIT_RETENTION, QUEEN_AUDIT_MAX_ROWS, recentQueenAudit } from "./queenAudit.js";
-import { runningBuildChange, runningBuildNotice } from "./version.js";
+import { runningBuildChange, runningBuildNotice, versionInfo } from "./version.js";
 import { existsSync, lstatSync, mkdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { dirname, join, sep } from "node:path";
@@ -19,12 +19,15 @@ import { describeLiveTasks, describeOneTask, liveBackgroundTasks, STALL_BOUND_SE
 import { MESSAGE_MAX_ROWS, MESSAGE_RETENTION } from "./leadMessage.js";
 import { CROSS_SESSION_CLOSE, postClaudeWake, senderAddress, SOCKET_WAKE_FOOTER } from "./claudeWake.js";
 import { readLeadTurnState } from "./leadState.js";
+import { retryQuietLeadMessages } from "./leadMessageDelivery.js";
 import { harnessFor, hasTranscriptSignal, paneClassifierFor, screenClassifiable, transcriptDirFor } from "./harnesses.js";
 import { transcriptDir, readContextFill } from "./transcript.js";
 import { ageSecondsSince, describeLastLogEvent, humanizeAge, lastLogEvent, reportsAgentStateLog, } from "./stateProvenance.js";
 import { capturePane, foreignSocket, holdsHumanInput, liveTargets, maskChoiceMarker, observationFailed, paneInCopyMode, paneReissued, rowAlive, rowAliveProbe, rowLiveProbe, rowOwnership, renderTrailerView, sanitizeTail, sendText, tailCaptureLines, sleep, tmuxSocketPath, } from "./tmux.js";
 import { appendTeardown, NOT_ATTRIBUTED, sqlNow, teardownWindow, TEARDOWN_TRIGGER, } from "./teardown.js";
 export const WATCH_SCOPE_PROJECT = "project";
+const DELIVERED_BY = `pid ${process.pid}, ${versionInfo().line}`;
+const deliveredByForFiring = (timer) => timer.repeat_every_ms == null ? DELIVERED_BY : `${DELIVERED_BY}, firing #${timer.fire_count}`;
 const isStandingWatch = (timer) => timer.watch_scope === WATCH_SCOPE_PROJECT;
 export const DELIVER_SOCKET_JOIN = `LEFT JOIN agents ON agents.id = (
   SELECT a.id FROM agents a WHERE a.actor_id = wakes.deliver_actor
@@ -466,8 +469,13 @@ export function checkConfirmations() {
         WHERE ${sentAt} IS NOT NULL AND confirmed_at IS NULL AND ${sentAt} >= datetime('now', ?) LIMIT 1`).get(LOG_RETENTION);
         if (!pending)
             return;
+        stmt(`UPDATE wakes SET confirmed_at = (${repeatingEvidenceSql("MIN(ev.created_at)")})
+       WHERE ${REPEATING_SOCKET_FIRING} AND socket_attempt_at IS NOT NULL AND confirmed_at IS NULL
+         AND socket_attempt_at >= datetime('now', ?)
+         AND EXISTS (${repeatingEvidenceSql("1")})`).run(LOG_RETENTION);
         stmt(`UPDATE wakes SET confirmed_at = (${confirmationQuery})
        WHERE ${sentAt} IS NOT NULL AND confirmed_at IS NULL AND ${sentAt} >= datetime('now', ?)
+         AND NOT (${REPEATING_SOCKET_FIRING})
          AND EXISTS (${confirmationQuery.replace("MIN(created_at)", "1")})`).run(LOG_RETENTION);
     }
     catch {
@@ -513,6 +521,7 @@ export async function tick(snapshot) {
                 await maybeFireIdle(timer, snapshot, now, choices);
         }
         await retryUnconfirmedSocketWakes(snapshot, choices);
+        await retryQuietLeadMessages(snapshot);
     }
     catch {
     }
@@ -569,11 +578,12 @@ function forgetPaneAnswers(pane, choices) {
     noDialogUntil.delete(pane);
 }
 function holdTimer(timer, reason) {
+    const count = timer.fire_count ?? null;
     bestEffortRun(`UPDATE wakes SET held_at = datetime('now'), held_reason = ?,
        first_held_at = COALESCE(CASE WHEN held_at IS NULL THEN NULL ELSE first_held_at END, datetime('now'))
      WHERE id = ? AND cancelled_at IS NULL
-       AND (fired_at IS NULL OR (repeat_every_ms IS NOT NULL AND due_at = ?)
-         OR (${socketAwaitingWhere()}))`, reason, timer.id, timer.due_at);
+       AND (fired_at IS NULL OR (repeat_every_ms IS NOT NULL AND due_at = ? AND (? IS NULL OR fire_count = ?))
+         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)";
 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 " +
@@ -658,6 +668,8 @@ function conversationHoldsWake(timer, snapshot) {
     }
     return (stmt(`SELECT 1 AS hit FROM agent_state_log
         WHERE actor_id = ? AND event = 'prompt' AND CASE WHEN json_valid(payload) THEN COALESCE(json_extract(payload, '$.prompt'), payload) ELSE payload END NOT LIKE '%[hive wake #%' AND CASE WHEN json_valid(payload) THEN COALESCE(json_extract(payload, '$.prompt'), payload) ELSE payload END NOT LIKE '[hive:%'
+          AND CASE WHEN json_valid(payload) THEN COALESCE(json_extract(payload, '$.prompt'), payload) ELSE payload END NOT LIKE '<task-notification>%'
+          AND CASE WHEN json_valid(payload) THEN COALESCE(json_extract(payload, '$.prompt'), payload) ELSE payload END NOT LIKE '<cross-session-message from="%" from-name="hive">' || char(10) || '[hive:worker %] [message #%,%' || char(10) || '</cross-session-message>%'
           AND created_at >= datetime('now', ?)
         ORDER BY id DESC LIMIT 1`).get(timer.deliver_actor, CONVERSATION_HOLD_TTL) !== undefined);
 }
@@ -1610,28 +1622,33 @@ async function fireDelay(timer, snapshot, choices) {
         bestEffortRun("UPDATE wakes SET cancelled_at = datetime('now') WHERE id = ? AND created_at IS ?", timer.id, timer.created_at);
         return;
     }
+    if (timer.repeat_every_ms != null && repeatingFiringPending(timer.id))
+        return;
     await withPaneClaim(timer, () => fireDelayClaimed(timer, snapshot, choices));
 }
 async function fireDelayClaimed(timer, snapshot, choices) {
     const decision = deliverable(timer, snapshot, choices);
     if (!decision.ok)
         return false;
-    let claimed;
+    let firing = timer;
     if (timer.repeat_every_ms != null) {
         const seconds = Math.max(1, Math.round(timer.repeat_every_ms / 1000));
-        claimed =
-            stmt(`UPDATE wakes SET due_at = datetime('now', printf('+%d seconds', ?)),
-           fired_at = datetime('now'), fire_count = fire_count + 1,
-           typed_at = NULL, confirmed_at = NULL, held_at = NULL, held_reason = NULL, typed_busy = NULL,
-           typed_seen = NULL, first_held_at = NULL
-         WHERE id = ? AND due_at IS ? AND body IS ? AND repeat_every_ms IS ? AND cancelled_at IS NULL`).run(seconds, timer.id, timer.due_at, timer.body, timer.repeat_every_ms).changes === 1;
-    }
-    else {
-        claimed = claimOneShot(timer);
+        const claimed = stmt(`UPDATE wakes SET due_at = datetime('now', printf('+%d seconds', ?)),
+         fired_at = datetime('now'), fire_count = fire_count + 1,
+         typed_at = NULL, confirmed_at = NULL, held_at = NULL, held_reason = NULL, typed_busy = NULL,
+         typed_seen = NULL, first_held_at = NULL,
+         socket_attempt_at = NULL, socket_delivery_note = NULL, delivery_method = NULL, delivered_by = NULL
+       WHERE id = ? AND due_at IS ? AND body IS ? AND repeat_every_ms IS ? AND cancelled_at IS NULL
+         AND fire_count = ? AND NOT COALESCE((${REPEATING_FIRING_PENDING}), 0)
+       RETURNING fire_count, fired_at`).get(seconds, timer.id, timer.due_at, timer.body, timer.repeat_every_ms, timer.fire_count);
+        if (claimed === undefined)
+            return false;
+        firing = { ...timer, fire_count: claimed.fire_count, fired_at: claimed.fired_at, socket_attempt_at: null, socket_delivery_note: null, delivery_method: null };
     }
-    if (!claimed)
+    else if (!claimOneShot(timer)) {
         return false;
-    await deliver(timer, "", choices, decision.typedSeen, decision.firstHeldAt, decision.owner);
+    }
+    await deliver(firing, "", choices, decision.typedSeen, decision.firstHeldAt, decision.owner);
     return true;
 }
 function claimOneShot(timer) {
@@ -1889,14 +1906,39 @@ export function shortRenderForLeadDelivery(timer) {
     return standingNoticeBodyShort(timer, candidates, timer.id);
 }
 // The claim already happened, so this records why and never re-arms or replays the wake.
-function recordLostAfterClaim(timer, pasted, why) {
+function recordLostAfterClaim(timer, pasted, why, firing = null) {
     bestEffortRun(`UPDATE wakes SET held_reason = ?,
        typed_at = CASE WHEN ? = 1 THEN strftime('%Y-%m-%d %H:%M:%f', 'now') ELSE typed_at END,
        cancelled_at = CASE WHEN repeat_every_ms IS NULL THEN datetime('now') ELSE cancelled_at END
-     WHERE id = ?`, HELD_REASON_OWNERSHIP_LOST_AFTER_CLAIM + why + (pasted ? " The body was pasted; no Enter was sent." : ""), pasted ? 1 : 0, timer.id);
+     WHERE id = ? AND (? IS NULL OR fire_count = ?)`, HELD_REASON_OWNERSHIP_LOST_AFTER_CLAIM + why + (pasted ? " The body was pasted; no Enter was sent." : ""), pasted ? 1 : 0, timer.id, firing, firing);
 }
-export const DELIVERY_METHOD = { socket: "socket", pty: "pty", ptyAfterSocketTimeout: "pty-after-socket-timeout" };
+export const DELIVERY_METHOD = {
+    socket: "socket",
+    socketRepeating: "socket-repeating",
+    pty: "pty",
+    ptyAfterSocketTimeout: "pty-after-socket-timeout",
+};
 export const socketAwaitingWhere = (prefix = "") => `${prefix}delivery_method = '${DELIVERY_METHOD.socket}' AND ${prefix}confirmed_at IS NULL AND ${prefix}typed_at IS NULL AND ${prefix}cancelled_at IS NULL`;
+// An attempt older than the row's latest claim belongs to an earlier firing (an old-build claim leaves it behind).
+const currentAttempt = (p) => `${p}socket_attempt_at IS NOT NULL AND ${p}confirmed_at IS NULL AND ${p}typed_at IS NULL AND ${p}cancelled_at IS NULL
+   AND ${p}fired_at IS NOT NULL AND ${p}socket_attempt_at >= ${p}fired_at`;
+const repeatingSocketAwaitingWhere = (prefix = "") => `${prefix}delivery_method = '${DELIVERY_METHOD.socketRepeating}' AND ${currentAttempt(prefix)}`;
+const FIRING_DROPPED_NOTE = "dropped";
+const repeatingFallbackClaimedWhere = (prefix = "") => `${prefix}repeat_every_ms IS NOT NULL AND ${prefix}delivery_method = '${DELIVERY_METHOD.ptyAfterSocketTimeout}' AND ${currentAttempt(prefix)}
+   AND ${prefix}socket_delivery_note IS NOT '${FIRING_DROPPED_NOTE}'`;
+// Bounded like retry and confirmation: past retention neither can settle it, so it must stop deferring.
+const REPEATING_FIRING_PENDING = `((${repeatingSocketAwaitingWhere()}) OR (${repeatingFallbackClaimedWhere()}))
+  AND socket_attempt_at >= datetime('now', '${LOG_RETENTION}')`;
+const REPEATING_SOCKET_FIRING = `repeat_every_ms IS NOT NULL AND COALESCE(delivery_method, '') IN ('${DELIVERY_METHOD.socketRepeating}', '${DELIVERY_METHOD.ptyAfterSocketTimeout}')`;
+function repeatingFiringPending(id) {
+    try {
+        return stmt(`SELECT 1 AS hit FROM wakes WHERE id = ? AND (${REPEATING_FIRING_PENDING})`).get(id) !== undefined;
+    }
+    catch {
+        return true;
+    }
+}
+const firingMarker = (timer) => `[hive wake #${timer.id} firing #${timer.fire_count}`;
 const SOCKET_CONFIRM_GRACE_SECONDS = 60;
 const withReDelivered = (note) => (note ? `${note}, re-delivered` : "re-delivered");
 const promptEvidenceSql = (lowerBound) => `
@@ -1904,14 +1946,30 @@ const promptEvidenceSql = (lowerBound) => `
         WHERE actor_id = wakes.deliver_actor AND event = 'prompt' AND created_at >= ${lowerBound}
           AND (payload LIKE '%[hive wake #' || wakes.id || ']%'
                OR payload LIKE '%[hive wake #' || wakes.id || ',%')`;
+const ENVELOPE_OPEN = '<cross-session-message from="';
+const ENVELOPE_SENDER_CLOSE = '" from-name="hive">';
+const EV_PROMPT = "(CASE WHEN json_valid(ev.payload) THEN COALESCE(json_extract(ev.payload, '$.prompt'), '') ELSE ev.payload END)";
+const EV_MARKER = "('[hive wake #' || wakes.id || ' firing #' || wakes.fire_count)";
+const markerAt = (start) => `substr(${EV_PROMPT}, ${start}, length(${EV_MARKER}) + 1) IN (${EV_MARKER} || ']', ${EV_MARKER} || ',')`;
+const EV_HEADER_END = `instr(${EV_PROMPT}, char(10))`;
+// The current firing's exact marker, at prompt offset 0 (typed) or opening hive's envelope body (socket).
+const repeatingEvidenceSql = (select) => `
+       SELECT ${select} FROM agent_state_log ev
+        WHERE ev.actor_id = wakes.deliver_actor AND ev.event = 'prompt' AND ev.created_at >= wakes.socket_attempt_at
+          AND (${markerAt("1")}
+               OR (${EV_HEADER_END} > ${ENVELOPE_OPEN.length + ENVELOPE_SENDER_CLOSE.length}
+                   AND substr(${EV_PROMPT}, 1, ${ENVELOPE_OPEN.length}) = '${ENVELOPE_OPEN}'
+                   AND substr(${EV_PROMPT}, ${EV_HEADER_END} - ${ENVELOPE_SENDER_CLOSE.length}, ${ENVELOPE_SENDER_CLOSE.length}) = '${ENVELOPE_SENDER_CLOSE}'
+                   AND instr(substr(${EV_PROMPT}, ${ENVELOPE_OPEN.length + 1}, ${EV_HEADER_END} - ${ENVELOPE_OPEN.length + ENVELOPE_SENDER_CLOSE.length + 1}), '"') = 0
+                   AND ${markerAt(`${EV_HEADER_END} + 1`)}
+                   AND instr(${EV_PROMPT}, char(10) || '${CROSS_SESSION_CLOSE}') > ${EV_HEADER_END}))`;
 function quietMessagingOn(projectId) {
     const project = stmt("SELECT path FROM projects WHERE id = ?").get(projectId);
     return project !== undefined && loadProjectYml(project.path).config?.quiet_messaging === true;
 }
-// Only a one-shot wake to a live, row-owned Claude lead whose socket was registered by this pane epoch.
+// Only a wake to a live, row-owned Claude lead whose socket was registered by this pane epoch.
 function socketRoute(timer, owner) {
     return (owner !== null &&
-        timer.repeat_every_ms == null &&
         isLeadActorId(timer.deliver_actor) &&
         harnessFor(timer.deliver_command).name === "claude" &&
         timer.deliver_messaging_socket !== "" &&
@@ -1924,23 +1982,72 @@ function socketStillRegistered(timer, owner) {
     requireStillOwned(owner.rowId, owner.identity, `wake #${timer.id} socket delivery`);
     const row = stmt(`SELECT claude_messaging_socket AS socket, claude_messaging_pane_pid AS pid, pane_pid FROM agents
       WHERE id = ? AND status = 'running' AND kind = 'lead'`).get(owner.rowId);
-    const wake = stmt("SELECT 1 AS live FROM wakes WHERE id = ? AND cancelled_at IS NULL").get(timer.id);
+    const wake = timer.repeat_every_ms == null
+        ? stmt("SELECT 1 AS live FROM wakes WHERE id = ? AND cancelled_at IS NULL").get(timer.id)
+        : stmt("SELECT 1 AS live FROM wakes WHERE id = ? AND cancelled_at IS NULL AND fire_count = ?").get(timer.id, timer.fire_count);
     return (wake !== undefined &&
         row !== undefined &&
         row.socket === timer.deliver_messaging_socket &&
         row.pid === timer.deliver_messaging_pane_pid &&
         row.pid === row.pane_pid);
 }
+// A failed stamp means the firing was cancelled or superseded, so nothing is posted.
+function stampRepeatingAttempt(timer, note, firstHeldAt) {
+    try {
+        return (stmt(`UPDATE wakes SET socket_attempt_at = strftime('%Y-%m-%d %H:%M:%f', 'now'), socket_delivery_note = ?,
+           delivery_method = ?, delivered_by = ?, first_held_at = ?, held_at = NULL, held_reason = NULL, confirmed_at = NULL
+         WHERE id = ? AND fire_count = ? AND cancelled_at IS NULL AND typed_at IS NULL AND socket_attempt_at IS NULL`).run(note, DELIVERY_METHOD.socketRepeating, deliveredByForFiring(timer), firstHeldAt, timer.id, timer.fire_count).changes === 1);
+    }
+    catch {
+        return false;
+    }
+}
+// At most one fallback per (id, firing): the method leaves socket-repeating here and never returns to it.
+function claimRepeatingFallback(timer) {
+    try {
+        return (stmt(`UPDATE wakes SET delivery_method = ?, delivered_by = ?
+          WHERE id = ? AND fire_count = ? AND ${repeatingSocketAwaitingWhere()}
+            AND NOT EXISTS (${repeatingEvidenceSql("1")})`).run(DELIVERY_METHOD.ptyAfterSocketTimeout, deliveredByForFiring(timer), timer.id, timer.fire_count).changes === 1);
+    }
+    catch {
+        return false;
+    }
+}
+class FiringSuperseded extends Error {
+}
+// Nothing reached the pane, so this firing is settled as dropped: the next one delivers, nothing replays it.
+// The marker lives in socket_delivery_note because hive lead's re-point clears held_reason.
+function dropRepeatingFiring(timer, firing, err) {
+    const why = err instanceof Error ? err.message : String(err);
+    bestEffortRun(`UPDATE wakes SET socket_delivery_note = ?, held_reason = ?
+      WHERE id = ? AND fire_count = ? AND delivery_method = ? AND typed_at IS NULL`, FIRING_DROPPED_NOTE, `${HELD_REASON_OWNERSHIP_LOST_AFTER_CLAIM}${why} Firing #${firing} was not delivered; the next firing goes out on schedule.`, timer.id, firing, DELIVERY_METHOD.ptyAfterSocketTimeout);
+}
+function requireCurrentFiring(id, firing) {
+    const row = stmt("SELECT 1 AS hit FROM wakes WHERE id = ? AND fire_count = ? AND cancelled_at IS NULL").get(id, firing);
+    if (row === undefined)
+        throw new FiringSuperseded(`wake #${id} firing #${firing} was superseded`);
+}
 async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner, fallback = false) {
     const tail = watchedTail(timer);
     const body = (isLeadActorId(timer.deliver_actor) ? shortRenderForLeadDelivery(timer) : null) ?? timer.body;
     const staleness = noticeStalenessNote(timer);
+    // A repeating wake that took the socket keeps its firing number in every marker and every write.
+    let firing = fallback && timer.delivery_method === DELIVERY_METHOD.socketRepeating ? timer.fire_count : null;
     if (!fallback && socketRoute(timer, owner)) {
-        const text = `[hive wake #${timer.id}${note ? `, ${note}` : ""}] ${body + staleness + tail}\n\n${SOCKET_WAKE_FOOTER}`;
+        const repeating = timer.repeat_every_ms != null;
+        const head = repeating ? firingMarker(timer) : `[hive wake #${timer.id}`;
+        const text = `${head}${note ? `, ${note}` : ""}] ${body + staleness + tail}\n\n${SOCKET_WAKE_FOOTER}`;
         if (!text.includes(CROSS_SESSION_CLOSE)) {
-            bestEffortRun(`UPDATE wakes SET socket_attempt_at = strftime('%Y-%m-%d %H:%M:%f', 'now'), socket_delivery_note = ?,
-           delivery_method = ?, first_held_at = ?, held_at = NULL, held_reason = NULL, confirmed_at = NULL
-         WHERE id = ?`, note, DELIVERY_METHOD.socket, firstHeldAt, timer.id);
+            if (repeating) {
+                if (!stampRepeatingAttempt(timer, note, firstHeldAt))
+                    return;
+                firing = timer.fire_count;
+            }
+            else {
+                bestEffortRun(`UPDATE wakes SET socket_attempt_at = strftime('%Y-%m-%d %H:%M:%f', 'now'), socket_delivery_note = ?,
+             delivery_method = ?, delivered_by = ?, first_held_at = ?, held_at = NULL, held_reason = NULL, confirmed_at = NULL
+           WHERE id = ?`, note, DELIVERY_METHOD.socket, deliveredByForFiring(timer), firstHeldAt, timer.id);
+            }
             const posted = await postClaudeWake({
                 socketPath: timer.deliver_messaging_socket,
                 senderAddress: senderAddress(join(dataDir, "wake-sender.sock")),
@@ -1951,12 +2058,14 @@ async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner, fall
                 forgetPaneAnswers(timer.deliver_pane, choices);
                 return;
             }
+            if (firing !== null && !claimRepeatingFallback(timer))
+                return;
             note = withReDelivered(note);
             fallback = true;
         }
     }
-    const prefix = `[hive wake #${timer.id}${note ? `, ${note}` : ""}] ` +
-        (fallback ? `If you already handled wake #${timer.id}, ignore this.\n` : "");
+    const named = firing === null ? `wake #${timer.id}` : `wake #${timer.id} firing #${firing}`;
+    const prefix = `[hive ${named}${note ? `, ${note}` : ""}] ` + (fallback ? `If you already handled ${named}, ignore this.\n` : "");
     const method = fallback ? DELIVERY_METHOD.ptyAfterSocketTimeout : DELIVERY_METHOD.pty;
     let typedBusy;
     try {
@@ -1967,9 +2076,9 @@ async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner, fall
         typedBusy = null;
     }
     const recordTyped = () => bestEffortRun(`UPDATE wakes SET typed_at = strftime('%Y-%m-%d %H:%M:%f', 'now'), typed_busy = ?,
-         typed_seen = ?, first_held_at = ?, held_at = NULL, held_reason = NULL, delivery_method = ?,
+         typed_seen = ?, first_held_at = ?, held_at = NULL, held_reason = NULL, delivery_method = ?, delivered_by = ?,
          confirmed_at = CASE WHEN socket_attempt_at IS NULL THEN NULL ELSE confirmed_at END
-       WHERE id = ?`, typedBusy, typedSeen, firstHeldAt, method, timer.id);
+       WHERE id = ? AND (? IS NULL OR fire_count = ?)`, typedBusy, typedSeen, firstHeldAt, method, deliveredByForFiring(timer), timer.id, firing, firing);
     const box = cacheEntry(timer.deliver_pane, choices).box;
     const strandedTextWouldHold = box !== undefined && box !== null && box.state !== "unknown";
     let pasted = false;
@@ -1978,15 +2087,27 @@ async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner, fall
             pasted = true;
             if (strandedTextWouldHold)
                 recordTyped();
-        }, undefined, owner ? () => requireStillOwned(owner.rowId, owner.identity, `wake #${timer.id} delivery`) : undefined);
+        }, undefined, owner || firing !== null
+            ? () => {
+                if (owner)
+                    requireStillOwned(owner.rowId, owner.identity, `wake #${timer.id} delivery`);
+                if (firing !== null)
+                    requireCurrentFiring(timer.id, firing);
+            }
+            : undefined);
     }
     catch (err) {
-        if (fallback && !pasted) {
-            bestEffortRun("UPDATE wakes SET delivery_method = ? WHERE id = ? AND typed_at IS NULL", DELIVERY_METHOD.socket, timer.id);
+        if (fallback && !pasted && firing === null) {
+            bestEffortRun("UPDATE wakes SET delivery_method = ?, delivered_by = ? WHERE id = ? AND typed_at IS NULL", DELIVERY_METHOD.socket, deliveredByForFiring(timer), timer.id);
         }
+        if (err instanceof FiringSuperseded)
+            return;
+        if (firing !== null && !pasted)
+            dropRepeatingFiring(timer, firing, err);
         if (!(err instanceof PaneOwnershipLost))
             throw err;
-        recordLostAfterClaim(timer, pasted, err.message);
+        if (firing === null || pasted)
+            recordLostAfterClaim(timer, pasted, err.message, firing);
         return;
     }
     finally {
@@ -2011,9 +2132,11 @@ async function fallbackClaimed(timer, snapshot, choices) {
     const decision = deliverable(timer, snapshot, choices);
     if (!decision.ok)
         return false;
-    const claimed = stmt(`UPDATE wakes SET delivery_method = ?
-        WHERE id = ? AND ${socketAwaitingWhere()}
-          AND NOT EXISTS (${promptEvidenceSql("wakes.socket_attempt_at").replace("MIN(created_at)", "1")})`).run(DELIVERY_METHOD.ptyAfterSocketTimeout, timer.id).changes === 1;
+    const claimed = timer.delivery_method === DELIVERY_METHOD.socketRepeating
+        ? claimRepeatingFallback(timer)
+        : stmt(`UPDATE wakes SET delivery_method = ?, delivered_by = ?
+            WHERE id = ? AND ${socketAwaitingWhere()}
+              AND NOT EXISTS (${promptEvidenceSql("wakes.socket_attempt_at").replace("MIN(created_at)", "1")})`).run(DELIVERY_METHOD.ptyAfterSocketTimeout, deliveredByForFiring(timer), timer.id).changes === 1;
     if (!claimed)
         return false;
     await deliver(timer, withReDelivered(timer.socket_delivery_note), choices, decision.typedSeen, decision.firstHeldAt, decision.owner, true);
@@ -2022,7 +2145,7 @@ async function fallbackClaimed(timer, snapshot, choices) {
 async function retryUnconfirmedSocketWakes(snapshot, choices) {
     const awaiting = stmt(`SELECT wakes.*, ${DELIVER_ROW_COLUMNS}
        FROM wakes ${DELIVER_SOCKET_JOIN}
-      WHERE ${socketAwaitingWhere("wakes.")}
+      WHERE ((${socketAwaitingWhere("wakes.")}) OR (${repeatingSocketAwaitingWhere("wakes.")}))
         AND wakes.socket_attempt_at >= datetime('now', ?)`).all(LOG_RETENTION);
     for (const timer of awaiting) {
         if (!socketFallbackDue(timer))

package/dist/tmux.js

@@ -123,7 +123,11 @@ function tmuxWithin(timeoutMs, ...args) {
         throw new TmuxError(`tmux ${args[0]} failed${detail ? `: ${detail}` : ""}`, detail ?? "");
     }
 }
-const NOTHING_THERE = /no server running|error connecting to|no current target|can't find (pane|window|session)/;
+const NOTHING_THERE = /no server running|no current target|can't find (pane|window|session)/;
+// A connect failure is an empty server only when the errno proves nothing listens; EACCES/EPERM
+// (a sandboxed caller) and any unreadable reason mean nobody answered.
+const CONNECT_FAILED = /error connecting to .*\(([^)]*)\)\s*$/;
+const NO_LISTENER = /^(No such file or directory|Connection refused)$/;
 // "no server running" is tmux ANSWERING that the socket is empty. A missing binary is nobody
 // answering at all, and the two must never read the same to anything that reports a death.
 export function tmuxNotInstalled(e) {
@@ -136,6 +140,9 @@ export function tmuxSaysNothingThere(e) {
         return false;
     if (e.notInstalled)
         return true;
+    const reason = CONNECT_FAILED.exec(e.stderr)?.[1];
+    if (reason !== undefined)
+        return NO_LISTENER.test(reason);
     return NOTHING_THERE.test(e.stderr);
 }
 function quietTmux(...args) {
@@ -854,7 +861,12 @@ function leadingRunIsFaint(s) {
             faint = false;
             continue;
         }
-        for (const p of params) {
+        for (let i = 0; i < params.length; i++) {
+            const p = params[i];
+            if (p === "38" || p === "48" || p === "58") {
+                i += params[i + 1] === "5" ? 2 : params[i + 1] === "2" ? 4 : 0;
+                continue;
+            }
             if (p === "0")
                 faint = false;
             else if (p === "2")
@@ -922,19 +934,42 @@ function classifyInputBox(rows, promptRowIndex, boxBottom) {
         .slice(0, TAIL_LINE_CHARS);
     return { state: text === "" ? "empty" : dim ? "ghost" : "pending", text };
 }
-export function inputBoxState(target) {
+const SNAPSHOT_ROWS = 10;
+const SNAPSHOT_ROW_CHARS = 120;
+const snapshotRow = (row) => stripControlBytes(stripSgr(row))
+    .trimEnd()
+    .replace(/─{4,}/g, (run) => `─×${run.length}`)
+    .slice(0, SNAPSHOT_ROW_CHARS);
+function snapshotRows(rows, anchor) {
+    if (anchor === null) {
+        return rows.map(snapshotRow).filter((row) => row !== "").slice(-SNAPSHOT_ROWS);
+    }
+    return rows.slice(anchor.top, anchor.bottom + 1).map(snapshotRow).slice(0, SNAPSHOT_ROWS);
+}
+function promptSgrOf(rows, anchor) {
+    if (anchor === null || anchor.prompt === null)
+        return "";
+    const row = rows[anchor.prompt];
+    const after = row.slice(row.indexOf(PROMPT_GLYPH_NBSP) + PROMPT_GLYPH_NBSP.length);
+    return (/^(?:\x1b\[[0-9;]*m)*/.exec(after)?.[0] ?? "").replace(/\x1b/g, "").slice(0, 60);
+}
+export function inputBoxSnapshot(target) {
     try {
         const raw = tmux("capture-pane", "-p", "-e", "-t", target, "-S", `-${tailCaptureLines()}`);
         const rows = raw.split("\n");
-        const box = findInputBox(rows);
-        if (box === null)
-            return null;
-        return box.prompt === null ? { state: "unknown", text: "" } : classifyInputBox(rows, box.prompt, box.bottom);
+        const anchor = findInputBox(rows);
+        const box = anchor === null
+            ? null
+            : anchor.prompt === null
+                ? { state: "unknown", text: "" }
+                : classifyInputBox(rows, anchor.prompt, anchor.bottom);
+        return { box, rows: snapshotRows(rows, anchor), promptSgr: promptSgrOf(rows, anchor) };
     }
     catch {
         return null;
     }
 }
+export const inputBoxState = (target) => inputBoxSnapshot(target)?.box ?? null;
 const NOISE_ROW = /^[\s\u2500-\u257F\u2580-\u259F\u2800-\u28FF]*$/;
 const FOOTER_KEEP = /esc to interrupt|\d+ (?:shell|background|task|monitor|local agent|team)s?\b|remote dynamic workflow|cloud session|ultraplan needs your input/i;
 const OSC_SEQUENCE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;

package/dist/tools/agents.js

@@ -10,7 +10,8 @@ import { currentActor, findProjectForDir, getProject, linkedWorktreePrimaryRoot,
 import { commandHead, harnessFor, harnessNames, readOnlyExtraArgsAllowed, paneClassifierFor, resolvedCommandPrefix, screenClassifiable, } from "../harnesses.js";
 import { ensureWorkerHooksFile } from "../hooks.js";
 import { activeProfile, allowedAgents, loadProjectYml } from "../projectYml.js";
-import { classifyMiss, LEAD_MESSAGE_THRESHOLD, leadPointerMarker, missMessage, readLeadMessage, renderLeadPointer, senderTag, shortenedSendFailureClause, shortenedSendNote, storeLeadMessage, } from "../leadMessage.js";
+import { classifyMiss, DELIVERY_FIELDS, LEAD_MESSAGE_THRESHOLD, leadPointerMarker, missMessage, readLeadMessage, renderLeadPointer, senderTag, shortenedSendFailureClause, shortenedSendNote, storeLeadMessage, } from "../leadMessage.js";
+import { sendQuietLeadMessage } from "../leadMessageDelivery.js";
 import { run } from "../result.js";
 import { markGoneReported } from "../scheduler.js";
 import { agentIdentityEnv, branchAt, closeAgentRow, currentOwnership, discardOrphanedPane, isReservedAgentName, isRunningLeadActor, killAgentPane, launchAgent, LEAD_KIND, PaneOwnershipLost, paneIdentity, parkAgentRow, reapCodexHomeForClosedAgent, requireStillOwned, releaseParkRow, renameAgent, resumeAgent, storedLaunchOptions, } from "../spawn.js";
@@ -1126,7 +1127,7 @@ export function registerAgents(server) {
         };
     }));
     server.registerTool("agent_send", {
-        description: "Type into an agent's terminal, addressed by name (or agent_id). text of any shape is prefixed with the sender tag, delivered as one bracketed paste and submitted with Enter unless submit=false. ONE EXCEPTION: text over 300 characters sent to a LEAD by anyone who is not that lead is stored and delivered as a one-line pointer instead, because a lead's pane is a human's own window; the receipt says so and names agent_message_get for the full text. Worker-bound text is never shortened at any length. Alternatively pass keys (tmux key names like Escape, C-c, Enter). wait_ms (250-10000) returns the terminal tail after sending. A claude worker is already briefed by agent_spawn. A worker whose screen hive cannot classify is REFUSED on the text path entirely (its brief is at the spawn receipt's brief_path); keys still reaches it. A pane in tmux copy mode is REFUSED too, and retriably: tmux clears its bracketed-paste flag there, so the paste would lose its markers and the Enter would be eaten - leave copy mode (or agent_send(keys: [\"-X\", \"cancel\"]) to cancel it deliberately) and send again.",
+        description: "Type into an agent's terminal, addressed by name (or agent_id). text of any shape is prefixed with the sender tag, delivered as one bracketed paste and submitted with Enter unless submit=false. ONE EXCEPTION: text over 300 characters sent to a LEAD by anyone who is not that lead is stored and delivered as a one-line pointer instead, because a lead's pane is a human's own window; the receipt says so and names agent_message_get for the full text. Worker-bound text is never shortened at any length. With quiet_messaging on, a worker's submitted text to a Claude lead is stored with a message id and posted over the lead's messaging socket instead of typed (the same pointer when over 300 characters): the receipt says pending until the lead's prompt confirms it, hive types it into the pane once if no confirmation comes, and the socket post skips the pane checks below; do not resend a pending send. Alternatively pass keys (tmux key names like Escape, C-c, Enter). wait_ms (250-10000) returns the terminal tail after sending. A claude worker is already briefed by agent_spawn. A worker whose screen hive cannot classify is REFUSED on the text path entirely (its brief is at the spawn receipt's brief_path); keys still reaches it. A pane in tmux copy mode is REFUSED too, and retriably: tmux clears its bracketed-paste flag there, so the paste would lose its markers and the Enter would be eaten - leave copy mode (or agent_send(keys: [\"-X\", \"cancel\"]) to cancel it deliberately) and send again.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: true,
@@ -1151,6 +1152,7 @@ export function registerAgents(server) {
         let outgoing = args.text ?? "";
         const tag = senderTag(project.id, currentActor());
         let shortened = null;
+        let boxBefore = null;
         const withShortened = (receipt) => shortened === null
             ? receipt
             : {
@@ -1183,6 +1185,32 @@ export function registerAgents(server) {
                     "turning a text call into a keys call. Tab and newline are the only control characters " +
                     'allowed. To send an actual keystroke on purpose, use keys instead (e.g. keys: ["C-c"]).');
             }
+            const quiet = await sendQuietLeadMessage({
+                projectId: project.id,
+                fromActor: currentActor(),
+                target: agent,
+                text: args.text,
+                submit: args.submit !== false,
+            });
+            if (quiet !== null) {
+                if (quiet.sent) {
+                    confirmQueenWrite("agent_send", project.id, args, { sent: true, agent_id: agent.id }, auditIdentity);
+                }
+                if (args.wait_ms == null)
+                    return quiet;
+                await sleep(Math.min(Math.max(args.wait_ms, 250), 10000));
+                try {
+                    if (observeOwnership(agent) !== "live")
+                        throw new Error("not live");
+                    return { ...quiet, tail: capturePane(target, 15) };
+                }
+                catch {
+                    return {
+                        ...quiet,
+                        tail_note: "The terminal tail could not be read after the wait (the pane may have died or changed owner).",
+                    };
+                }
+            }
             if (!screenClassifiable(agent.command)) {
                 return {
                     agent_id: agent.id,
@@ -1235,7 +1263,9 @@ export function registerAgents(server) {
                 };
             }
             if (submitting) {
-                const box = sendClassifier.inputBoxState(target);
+                const snapshot = readInputBox(sendClassifier, target);
+                const box = snapshot?.box ?? null;
+                boxBefore = inputBoxBefore(snapshot);
                 if (holdsHumanInput(box)) {
                     return {
                         agent_id: agent.id,
@@ -1319,12 +1349,13 @@ export function registerAgents(server) {
                 sent: true,
                 ...tailField,
                 ...inputBoxField(agent.command, target),
+                ...(boxBefore === null ? {} : { input_box_before: boxBefore }),
             });
         }
         return withShortened({ agent_id: agent.id, name: agent.name, sent: true });
     }));
     server.registerTool("agent_message_get", {
-        description: "Read one agent-to-lead message in full, by the id in a \"[hive:worker NAME] [message #N ...]\" pointer line. hive stores a message here only when it shortens one: text over 300 characters sent to a lead by someone who is not that lead. Every other send is typed with its sender tag and stores nothing, so there is no id to read. Messages are pruned after 7 days, and a lookup for a pruned id says so rather than reporting it missing.",
+        description: "Read one agent-to-lead message in full, by the id in a \"[hive:worker NAME] [message #N ...]\" pointer line. hive stores a message here when it shortens one (text over 300 characters sent to a lead by someone who is not that lead) and, with quiet_messaging on, for every submitted worker send to a Claude lead, whose result then also carries its delivery state (delivery_status, delivery_method, socket_attempt_at, confirmed_at, fallback_claimed_at, typed_at, delivery_note and the accepted target). Every other send is typed with its sender tag and stores nothing, so there is no id to read. Messages are pruned after 7 days, and a lookup for a pruned id says so rather than reporting it missing.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -1349,6 +1380,9 @@ export function registerAgents(server) {
             chars: row.text.length,
             created_at: row.created_at,
             text: row.text,
+            ...(row.delivery_status === null
+                ? {}
+                : Object.fromEntries(DELIVERY_FIELDS.map((field) => [field, row[field]]))),
         };
     }));
     server.registerTool("agent_output", {
@@ -1528,3 +1562,21 @@ export function registerAgents(server) {
         };
     }));
 }
+function inputBoxBefore(snapshot) {
+    if (snapshot === null)
+        return { state: "unreadable" };
+    const { box, rows, promptSgr } = snapshot;
+    const sgr = promptSgr ? { prompt_sgr: promptSgr } : {};
+    const withRows = rows === undefined ? {} : { rows };
+    if (box === null)
+        return { state: "not_found", ...withRows, ...sgr };
+    if (box.state === "ghost")
+        return { state: "ghost", ...sgr };
+    return { state: box.state, text: box.text, ...withRows, ...sgr };
+}
+function readInputBox(classifier, target) {
+    if (classifier.inputBoxSnapshot)
+        return classifier.inputBoxSnapshot(target);
+    const box = classifier.inputBoxState(target);
+    return box === null ? null : { box };
+}

package/dist/tools/wakes.js

@@ -112,9 +112,23 @@ function deliveryState(t, hasChannel) {
                         ? "unconfirmed_busy"
                         : "unconfirmed",
         delivery_method: t.delivery_method,
+        delivered_by: t.delivered_by,
         socket_attempt_at: t.socket_attempt_at,
     };
 }
+function deliveredByNote(t) {
+    if (t.delivery_method === null)
+        return null;
+    if (t.delivered_by === null)
+        return "delivered by a hive build older than this field";
+    if (t.repeat_every_ms === null)
+        return null;
+    const firing = t.delivered_by.match(/, firing #(\d+)$/);
+    return firing !== null && Number(firing[1]) !== t.fire_count
+        ? `firing #${t.fire_count} was claimed by a hive build older than this field; ` +
+            "that build types it into the pane and does not record delivered_by"
+        : null;
+}
 export const truncateBody = (body) => body.length > 120 ? `${cutToUnitBudget(body, 120)}…` : body;
 function rejectUnsafeBody(body) {
     const bad = findUnsafeControlChar(body, TEXT_ALLOWED_CONTROL_CHARS);
@@ -486,8 +500,13 @@ export function registerWakes(server) {
     server.registerTool("wake_get", {
         description: "Read one wake-up by id, in this project, with its UNTRUNCATED body. wake_list truncates " +
             "body at 120 chars; use this to see exactly what a wake will say, or to confirm what " +
-            "wake_update just changed. Its delivery state includes delivery_method (socket, pty or " +
-            "pty-after-socket-timeout) and socket_attempt_at, set when a wake was posted to a Claude lead's socket.",
+            "wake_update just changed. Its delivery state includes delivery_method (socket, socket-repeating, pty or " +
+            "pty-after-socket-timeout), delivered_by (the pid and build of the server that last set the delivery method, " +
+            "plus the firing number for repeating wakes), " +
+            "and socket_attempt_at, set when a wake was posted to a Claude lead's socket; " +
+            "for a repeating wake both describe its current firing (fire_count). An older repeat claim is " +
+            "identified in delivered_by_note as a claim; the older build types the firing into the pane " +
+            "without recording delivered_by.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -511,6 +530,7 @@ export function registerWakes(server) {
             repeating: t.repeat_every_ms != null,
             fire_count: t.fire_count,
             cancelled_at: t.cancelled_at,
+            delivered_by_note: deliveredByNote(t),
             first_held_at: t.first_held_at,
             ...deliveryState(t, hasChannel),
         };
@@ -626,7 +646,7 @@ export function registerWakes(server) {
     server.registerTool("wake_list", {
         description: "List pending wake-ups in this project, plus recently_delivered: the last " +
             `${RECENTLY_FIRED_LIMIT} one-shot wakes that have already fired, with their delivery ` +
-            "state (typed_at, held_at/held_reason, confirmation, delivery_method, socket_attempt_at). A one-shot wake leaves the " +
+            "state (typed_at, held_at/held_reason, confirmation, delivery_method, delivered_by, socket_attempt_at). A one-shot wake leaves the " +
             "pending list the moment it fires; recently_delivered is where to check whether it " +
             "was actually typed and, if its target has a confirmation channel, acknowledged.",
         annotations: {

package/package.json

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