@cmgmyr/hive 1.8.0 → 1.9.1

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";
@@ -17,12 +17,17 @@ import { awaitingFirstPrompt, awaitingFirstPromptSql } from "./firstPrompt.js";
 import { evaluateLeadWatch, leadSubscription } from "./leadWatch.js";
 import { describeLiveTasks, describeOneTask, liveBackgroundTasks, STALL_BOUND_SECONDS, } from "./backgroundTasks.js";
 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
@@ -32,7 +37,9 @@ const DELIVER_ROW_COLUMNS = `COALESCE(agents.tmux_socket, '') AS deliver_socket,
   COALESCE(agents.pane_pid, '') AS deliver_pane_pid,
   COALESCE(agents.command, '') AS deliver_command,
   agents.id AS deliver_row_id, agents.status AS deliver_row_status,
-  COALESCE(agents.tmux_target, '') AS deliver_row_target`;
+  COALESCE(agents.tmux_target, '') AS deliver_row_target,
+  COALESCE(agents.claude_messaging_socket, '') AS deliver_messaging_socket,
+  COALESCE(agents.claude_messaging_pane_pid, '') AS deliver_messaging_pane_pid`;
 // A row's pid certifies only the pane that row records, never a different deliver_pane.
 const deliveryIdentity = (row) => ({
     tmux_target: row.deliver_pane,
@@ -455,18 +462,20 @@ function maybeGenerateDashboards() {
     }
 }
 export function checkConfirmations() {
-    const confirmationQuery = `
-       SELECT MIN(created_at) FROM agent_state_log
-        WHERE actor_id = wakes.deliver_actor AND event = 'prompt' AND created_at >= wakes.typed_at
-          AND (payload LIKE '%[hive wake #' || wakes.id || ']%'
-               OR payload LIKE '%[hive wake #' || wakes.id || ',%')`;
+    const sentAt = "COALESCE(wakes.socket_attempt_at, wakes.typed_at)";
+    const confirmationQuery = promptEvidenceSql(sentAt);
     try {
         const pending = stmt(`SELECT 1 AS hit FROM wakes
-        WHERE typed_at IS NOT NULL AND confirmed_at IS NULL AND typed_at >= datetime('now', ?) LIMIT 1`).get(LOG_RETENTION);
+        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 typed_at IS NOT NULL AND confirmed_at IS NULL AND typed_at >= datetime('now', ?)
+       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 {
@@ -511,6 +520,8 @@ export async function tick(snapshot) {
             else
                 await maybeFireIdle(timer, snapshot, now, choices);
         }
+        await retryUnconfirmedSocketWakes(snapshot, choices);
+        await retryQuietLeadMessages(snapshot);
     }
     catch {
     }
@@ -567,10 +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 = ?))`, 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 " +
@@ -655,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);
 }
@@ -931,7 +946,7 @@ const STANDING_EXPIRED_NOTE = "this standing watch has expired and nothing is wa
 const unreported = (condition, episode) => `NOT EXISTS (
     SELECT 1 FROM wake_idle_notices n LEFT JOIN wakes nt ON nt.id = n.notice_wake_id
      WHERE n.wake_id = ? AND n.agent_id = a.id AND n.condition = '${condition}' AND n.episode = ${episode}
-       AND NOT (nt.fired_at IS NOT NULL AND nt.typed_at IS NULL AND nt.cancelled_at IS NULL
+       AND NOT (nt.fired_at IS NOT NULL AND COALESCE(nt.typed_at, nt.socket_attempt_at) IS NULL AND nt.cancelled_at IS NULL
                 AND nt.fired_at < datetime('now', '${NOTICE_RETRY_AFTER}')))`;
 const CREW_COLUMNS = `a.id, a.name, a.actor_id, a.tmux_target, a.tmux_socket, a.pane_pid, a.agent_state,
    a.state_changed_at, a.status, a.command, a.kind, a.resumed_at, a.closed_at,
@@ -1174,7 +1189,7 @@ function rearmSpentEpisode(timerId, agentId, condition, episode) {
       WHERE wake_id = ? AND agent_id = ? AND condition = ? AND episode = ?
         AND notice_wake_id IS NOT NULL
         AND EXISTS (SELECT 1 FROM wakes t WHERE t.id = wake_idle_notices.notice_wake_id
-                      AND t.fired_at IS NOT NULL AND t.typed_at IS NULL AND t.cancelled_at IS NULL
+                      AND t.fired_at IS NOT NULL AND COALESCE(t.typed_at, t.socket_attempt_at) IS NULL AND t.cancelled_at IS NULL
                       AND t.fired_at < datetime('now', '${NOTICE_RETRY_AFTER}'))`).run(timerId, agentId, condition, episode);
 }
 function claimEpisode(timerId, agentId, condition, episode) {
@@ -1607,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) {
@@ -1886,16 +1906,167 @@ 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",
+    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) => `
+       SELECT MIN(created_at) FROM agent_state_log
+        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 wake to a live, row-owned Claude lead whose socket was registered by this pane epoch.
+function socketRoute(timer, owner) {
+    return (owner !== null &&
+        isLeadActorId(timer.deliver_actor) &&
+        harnessFor(timer.deliver_command).name === "claude" &&
+        timer.deliver_messaging_socket !== "" &&
+        timer.deliver_messaging_pane_pid !== "" &&
+        timer.deliver_messaging_pane_pid === timer.deliver_pane_pid &&
+        timer.deliver_row_target === timer.deliver_pane &&
+        quietMessagingOn(timer.project_id));
+}
+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 = 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;
+    }
 }
-async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner) {
+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 prefix = `[hive wake #${timer.id}${note ? `, ${note}` : ""}] `;
     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 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)) {
+            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")),
+                text,
+                beforeWrite: () => socketStillRegistered(timer, owner),
+            });
+            if (posted) {
+                forgetPaneAnswers(timer.deliver_pane, choices);
+                return;
+            }
+            if (firing !== null && !claimRepeatingFallback(timer))
+                return;
+            note = withReDelivered(note);
+            fallback = true;
+        }
+    }
+    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 {
         const lastEvent = lastLogEvent(timer.deliver_actor);
@@ -1905,22 +2076,38 @@ async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner) {
         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, confirmed_at = NULL
-       WHERE id = ?`, typedBusy, typedSeen, firstHeldAt, timer.id);
+         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 = ? 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;
     try {
-        await sendText(timer.deliver_pane, prefix + body + noticeStalenessNote(timer) + tail, true, () => {
+        await sendText(timer.deliver_pane, prefix + body + staleness + tail, true, () => {
             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 && 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 {
@@ -1929,6 +2116,43 @@ async function deliver(timer, note, choices, typedSeen, firstHeldAt, owner) {
     if (!strandedTextWouldHold)
         recordTyped();
 }
+// Measured from the lead's first turn end after the post, because a busy lead reads the post only then.
+function socketFallbackDue(timer) {
+    const firstStop = stmt("SELECT MIN(created_at) AS t FROM agent_state_log WHERE actor_id = ? AND event = 'stop' AND created_at >= ?").get(timer.deliver_actor, timer.socket_attempt_at).t;
+    let from = firstStop;
+    if (from === null) {
+        const turn = timer.deliver_row_id === null ? null : readLeadTurnState(timer.deliver_row_id);
+        if (turn !== null && turn.state === "working" && turn.pane_pid === timer.deliver_pane_pid)
+            return false;
+        from = timer.socket_attempt_at;
+    }
+    return stmt("SELECT (julianday('now') - julianday(?)) * 86400 >= ? AS due").get(from, SOCKET_CONFIRM_GRACE_SECONDS).due === 1;
+}
+async function fallbackClaimed(timer, snapshot, choices) {
+    const decision = deliverable(timer, snapshot, choices);
+    if (!decision.ok)
+        return false;
+    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);
+    return true;
+}
+async function retryUnconfirmedSocketWakes(snapshot, choices) {
+    const awaiting = stmt(`SELECT wakes.*, ${DELIVER_ROW_COLUMNS}
+       FROM wakes ${DELIVER_SOCKET_JOIN}
+      WHERE ((${socketAwaitingWhere("wakes.")}) OR (${repeatingSocketAwaitingWhere("wakes.")}))
+        AND wakes.socket_attempt_at >= datetime('now', ?)`).all(LOG_RETENTION);
+    for (const timer of awaiting) {
+        if (!socketFallbackDue(timer))
+            continue;
+        await withPaneClaim(timer, () => fallbackClaimed(timer, snapshot, choices));
+    }
+}
 export const DEFAULT_SCHEDULER_INTERVAL_MS = 3000;
 const MIN_SCHEDULER_INTERVAL_MS = 100;
 // Node clamps a setInterval delay above this to 1ms.

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 };
+}