commandmate 0.49.2 → 0.49.3

package/dist/server/src/lib/db/relay-db-hold.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * Resolving an `uncertain` delivery hold on a relay (Issue #4082).
+ *
+ * Split out of `relay-db` (Issue #4096); `relay-db` re-exports every name here,
+ * so callers (and every `vi.mock`) keep importing from `@/lib/db/relay-db`.
+ * This module must not import `relay-db` (no cycle).
+ *
+ * @module lib/db/relay-db-hold
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelayDeliveryHold = resolveRelayDeliveryHold;
+const types_1 = require("../../lib/relay/types");
+const logger_1 = require("../../lib/logger");
+const relay_db_base_1 = require("../../lib/db/relay-db-base");
+const logger = (0, logger_1.createLogger)('relay-db');
+/** The second slot's reply, or null when it cannot be read. */
+function readPendingReply(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const { body, payloadId, overlap } = parsed;
+    if (typeof body !== 'string' || typeof payloadId !== 'string')
+        return null;
+    return { body, payloadId, overlap: typeof overlap === 'string' ? overlap : null };
+}
+/** Thrown inside the transaction when a guarded write lost; rolls everything back. */
+class RelayHoldConflict extends Error {
+}
+/** `SET` assignments that drop the delivery hold. */
+const DROP_HOLD_SET = `
+  delivery_state = NULL, delivery_attempt_id = NULL, delivery_owner = NULL,
+  delivery_reason = NULL, delivery_at = NULL
+`;
+/** The guard every resolve write carries: the hold the caller named, unchanged. */
+const HELD_GUARD = `
+  id = ? AND payload_id = ? AND delivery_attempt_id = ? AND delivery_state = 'uncertain' AND state = ?
+`;
+const EMPTY_SLOT_SET = `pending_kind = NULL, pending_body = NULL, payload_id = NULL, ${DROP_HOLD_SET}`;
+function refuseHold(refusal, message) {
+    return { ok: false, refusal, message };
+}
+/** Read the held row and refuse it unless it is an `uncertain` hold the caller named. */
+function readResolvableHold(db, input) {
+    const refuse = refuseHold;
+    const row = db
+        .prepare(`
+        SELECT state, expires_at, pending_kind, payload_id, pending_reply, delivery_state, delivery_attempt_id
+        FROM session_relays WHERE id = ?
+      `)
+        .get(input.relayId);
+    if (!row)
+        return refuse('not_found', `Relay '${input.relayId}' not found`);
+    if (row.delivery_state === null)
+        return refuse('no_hold', 'The relay has no delivery hold (resolved, delivered or queued)');
+    if (row.delivery_state === 'attempting') {
+        return refuse('attempting', 'The payload is being delivered right now; only that delivery settles it');
+    }
+    if (row.delivery_state !== 'uncertain')
+        return refuse('not_allowed', `Unknown delivery state '${row.delivery_state}'`);
+    if (row.delivery_attempt_id === null || row.payload_id === null || input.attemptId === null) {
+        return refuse('not_allowed', 'The hold carries no attempt id and cannot be resolved');
+    }
+    if (row.payload_id !== input.payloadId || row.delivery_attempt_id !== input.attemptId) {
+        return refuse('stale', 'The hold names another payload or attempt (read the relay again)');
+    }
+    const kind = row.pending_kind;
+    if (kind !== 'reply' && kind !== 'prompt' && kind !== 'expired') {
+        return refuse('not_allowed', 'The held slot carries no payload');
+    }
+    return { ok: true, row, kind };
+}
+/** `retry`: queue the held payload again (not sent here). */
+function retryHold({ row, kind, open, now, guarded }) {
+    if (kind !== 'expired') {
+        if (!open)
+            return refuseHold('not_allowed', `Relay is already ${row.state}; a closed relay's ${kind} is not sent again`);
+        if (row.expires_at <= now)
+            return refuseHold('not_allowed', 'Relay has passed its deadline; its payload is not sent again');
+    }
+    guarded(DROP_HOLD_SET);
+    return { ok: true, requeued: true, promoted: false };
+}
+/** `confirm` / `discard`: empty the held slot (and close or promote as the table says). */
+function settleHold(ctx) {
+    const { db, input, now, row, kind, open, guarded } = ctx;
+    const emptySlot = EMPTY_SLOT_SET;
+    if (kind === 'reply' && open)
+        return settleOpenReply(ctx);
+    if (kind === 'prompt' && open && row.expires_at <= now) {
+        // Issue #4082: the deadline passed and the sweep has not run yet. The
+        // relay ends here exactly as if the sweep had found the notice held:
+        // closed as `expired`, no expiry notice queued for the composer, and a
+        // waiting reply dropped explicitly (the requester is told) rather than
+        // promoted — promoting it would only have let the sweep erase it
+        // silently and queue a fresh expiry notice after the settle.
+        guarded(`state = 'expired', ${emptySlot}, pending_reply = NULL`);
+        const dropped = row.pending_reply === null ? null : readPendingReply(row.pending_reply);
+        return {
+            ok: true,
+            requeued: false,
+            promoted: false,
+            expired: true,
+            discardedReply: row.pending_reply === null ? null : { payloadId: dropped?.payloadId ?? null },
+        };
+    }
+    if (!open && row.pending_reply !== null) {
+        // Issue #4082: a closed relay delivers nothing more. The reply the
+        // expiry sweep kept behind the held notice is dropped here, with the
+        // slot, in this transaction — explicitly, so the requester is told.
+        guarded(`${emptySlot}, pending_reply = NULL`);
+        const dropped = readPendingReply(row.pending_reply);
+        return { ok: true, requeued: false, promoted: false, discardedReply: { payloadId: dropped?.payloadId ?? null } };
+    }
+    guarded(emptySlot);
+    if (kind !== 'prompt' || !open || row.pending_reply === null) {
+        return { ok: true, requeued: false, promoted: false };
+    }
+    return promotePendingReplyAfterSettle(db, input, now, row, row.pending_reply);
+}
+/** `confirm` closes an open relay's held reply `delivered`; `discard` closes it `cancelled`. */
+function settleOpenReply({ input, now, guarded }) {
+    const emptySlot = EMPTY_SLOT_SET;
+    if (input.action === 'confirm') {
+        guarded(`state = 'delivered', sent_request_id = COALESCE(sent_request_id, ?), delivered_at = ?,
+           ${emptySlot}, pending_reply = NULL`, input.sentRequestId, now);
+    }
+    else {
+        guarded(`state = 'cancelled', ${emptySlot}, pending_reply = NULL`);
+    }
+    return { ok: true, requeued: false, promoted: false };
+}
+function promotePendingReplyAfterSettle(db, input, now, row, pendingReply) {
+    // The reply that finished while the notice was held takes the slot now,
+    // in this same transaction: nothing can stash in between.
+    const reply = readPendingReply(pendingReply);
+    if (!reply) {
+        // Unreadable: dropped, exactly as `promoteRelayPendingReply` drops it.
+        logger.warn('relay-hold-resolve-unreadable-pending-reply', { relayId: input.relayId });
+        db.prepare('UPDATE session_relays SET pending_reply = NULL WHERE id = ?').run(input.relayId);
+        return { ok: true, requeued: false, promoted: false };
+    }
+    const promoted = db
+        .prepare(`
+        UPDATE session_relays
+        SET pending_kind = 'reply', pending_body = ?, payload_id = ?, overlap = ?,
+            pending_reply = NULL, updated_at = ?
+        WHERE id = ? AND pending_kind IS NULL AND delivery_state IS NULL AND state = ?
+      `)
+        .run(reply.body, reply.payloadId, reply.overlap, now, input.relayId, row.state);
+    if (promoted.changes !== 1)
+        throw new RelayHoldConflict('pending reply could not be promoted');
+    return { ok: true, requeued: false, promoted: true };
+}
+/**
+ * Settle an `uncertain` delivery hold, once (Issue #4082).
+ *
+ * Keyed on the relay, the payload AND the attempt the caller read, and on the
+ * hold still being `uncertain`: an operation from an older screen (the payload
+ * was retried since, and a new attempt took it), a second operation on the
+ * same hold, and a hold whose delivery is typing (`attempting`) are refused,
+ * and nothing is written. Every write — the close, the emptied slots, the
+ * promoted reply — commits in ONE transaction; a database error rolls all of
+ * it back and is thrown (the caller answers 500).
+ *
+ * | payload | relay | confirm | retry | discard |
+ * |---|---|---|---|---|
+ * | reply | open | close `delivered`, slots emptied | queued again (deadline not passed) | close `cancelled`, both slots emptied |
+ * | prompt | open | slot emptied, the waiting reply promoted | queued again (deadline not passed) | as confirm |
+ * | expired | (closed) | slot emptied | queued again | slot emptied |
+ * | reply / prompt | closed | slot emptied, state kept | refused | slot emptied, state kept |
+ *
+ * Issue #4082: a closed relay's reply waiting in the second slot (the expiry
+ * sweep keeps it while the notice in front of it is held) is dropped by the
+ * confirm / discard that empties the slot, and reported as `discardedReply`.
+ * A prompt notice on an OPEN relay whose deadline has passed (the sweep has
+ * not run yet) is settled the same way, and the relay is closed `expired`
+ * in the same write (`expired: true`) with no expiry notice queued — so
+ * resolve-then-sweep ends where sweep-then-resolve does.
+ *
+ * `prompt_signature` is kept, so the same dialog is not told again; the send
+ * binding's `send_state` / `hold_reason` / observation are not touched.
+ * Nothing here types: a retried payload goes out through the pump.
+ */
+function resolveRelayDeliveryHold(db, input) {
+    const now = input.now ?? Date.now();
+    const refuse = (refusal, message) => ({ ok: false, refusal, message });
+    const decide = () => {
+        const checked = readResolvableHold(db, input);
+        if (!checked.ok)
+            return checked;
+        const { row, kind } = checked;
+        const open = (0, types_1.isOpenRelayState)(row.state);
+        // A guarded write that does not take exactly one row rolls the whole
+        // transaction back; `false` is never read as success.
+        const guarded = (setClause, ...setParams) => {
+            const result = db
+                .prepare(`UPDATE session_relays SET ${setClause}, updated_at = ? WHERE ${HELD_GUARD}`)
+                .run(...setParams, now, input.relayId, input.payloadId, input.attemptId, row.state);
+            if (result.changes !== 1)
+                throw new RelayHoldConflict('hold changed underneath the resolve');
+        };
+        const ctx = { db, input, now, row, kind, open, guarded };
+        if (input.action === 'retry')
+            return retryHold(ctx);
+        return settleHold(ctx);
+    };
+    // The relay the answer carries is read INSIDE the transaction, before it
+    // commits: a read that fails after the commit would answer 500 for a hold
+    // already settled (and, for a retry, before the pump was asked to send it).
+    // Failing here rolls the settle back with it, so a 500 still means
+    // "nothing was committed".
+    const decideAndRead = () => {
+        const decided = decide();
+        const relay = (0, relay_db_base_1.getRelayById)(db, input.relayId);
+        if (decided.ok && !relay)
+            throw new Error(`Relay '${input.relayId}' vanished while its hold was resolved`);
+        return { decided, relay };
+    };
+    let settled;
+    try {
+        settled = db.transaction(decideAndRead).immediate();
+    }
+    catch (error) {
+        if (!(error instanceof RelayHoldConflict))
+            throw error;
+        // Rolled back: nothing was written, so a failing read here commits nothing either.
+        settled = {
+            decided: refuse('stale', 'The hold changed while it was being resolved (read the relay again)'),
+            relay: (0, relay_db_base_1.getRelayById)(db, input.relayId),
+        };
+    }
+    const { decided, relay } = settled;
+    if (!decided.ok)
+        return { ...decided, relay };
+    return {
+        ok: true,
+        relay: relay,
+        requeued: decided.requeued,
+        promoted: decided.promoted,
+        discardedReply: decided.discardedReply ?? null,
+        expired: decided.expired === true,
+    };
+}

package/dist/server/src/lib/db/relay-db.js

@@ -17,40 +17,49 @@
  * @module lib/db/relay-db
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stashRelayPayload = exports.settleRelaySendState = exports.setRelayPendingReply = exports.setRelayHold = exports.reserveRelayBind = exports.replaceRelayPromptWithReply = exports.replaceRelayPromptWithPendingReply = exports.recordRelayInputBoundary = exports.promoteRelayPendingReply = exports.listRelaysWithPendingPayload = exports.listOpenBoundRelays = exports.getRelayPendingPayload = exports.getRelayBinding = exports.failOrphanedRelayBind = exports.explainRelayBindRefusal = exports.clearRelayPendingReply = exports.clearRelayPending = exports.clearRelayHeldCandidates = exports.appendRelayHeldCandidate = void 0;
+exports.countRelays = exports.resolveRelayDeliveryHold = exports.markRelayDelivered = exports.completeRelayReplyDelivery = exports.getRelayById = exports.stashRelayPayload = exports.settleRelaySendState = exports.setRelayPendingReply = exports.setRelayHold = exports.reserveRelayBind = exports.replaceRelayPromptWithReply = exports.replaceRelayPromptWithPendingReply = exports.RELAY_DELIVERY_SERVER_RESTARTED = exports.releaseRelayPayloadDelivery = exports.recoverInterruptedRelayDeliveryRefs = exports.recoverInterruptedRelayDeliveries = exports.recordRelayInputBoundary = exports.promoteRelayPendingReply = exports.listRelaysWithPendingPayload = exports.listRelaysWithDeliveryHold = exports.listOpenBoundRelays = exports.listDeliverableRelayPayloads = exports.isCurrentRelayPayloadAttempt = exports.holdRelayPayloadDelivery = exports.getRelayPendingPayload = exports.getRelayBinding = exports.failOrphanedRelayBind = exports.explainRelayBindRefusal = exports.completeRelayPromptDelivery = exports.countHeldRelays = exports.completeRelayPayloadDelivery = exports.clearRelayPendingReplyUnlessHeld = exports.clearRelayPendingReply = exports.clearRelayPending = exports.clearRelayHeldCandidates = exports.claimRelayPayloadDelivery = exports.appendRelayHeldCandidate = void 0;
 exports.createRelay = createRelay;
-exports.getRelayById = getRelayById;
 exports.listOpenRelaysTo = listOpenRelaysTo;
 exports.listOpenRelaysFrom = listOpenRelaysFrom;
 exports.getSessionRelaySummary = getSessionRelaySummary;
 exports.listOpenRelaysForWorktree = listOpenRelaysForWorktree;
 exports.countOpenRelaysBetween = countOpenRelaysBetween;
-exports.markRelayDelivered = markRelayDelivered;
 exports.markRelayPromptNotified = markRelayPromptNotified;
 exports.getRelayPromptSignature = getRelayPromptSignature;
 exports.markRelayExpired = markRelayExpired;
 exports.listExpiredOpenRelays = listExpiredOpenRelays;
 exports.cancelRelay = cancelRelay;
-exports.countRelays = countRelays;
 const crypto_1 = require("crypto");
 const types_1 = require("../../lib/relay/types");
-const logger_1 = require("../../lib/logger");
 const relay_bind_db_1 = require("../../lib/db/relay-bind-db");
 // Issue #3995: the send binding and the pending slots live in `relay-bind-db`;
 // re-exported so every caller (and every `vi.mock`) keeps this module's surface.
 var relay_bind_db_2 = require("../../lib/db/relay-bind-db");
 Object.defineProperty(exports, "appendRelayHeldCandidate", { enumerable: true, get: function () { return relay_bind_db_2.appendRelayHeldCandidate; } });
+Object.defineProperty(exports, "claimRelayPayloadDelivery", { enumerable: true, get: function () { return relay_bind_db_2.claimRelayPayloadDelivery; } });
 Object.defineProperty(exports, "clearRelayHeldCandidates", { enumerable: true, get: function () { return relay_bind_db_2.clearRelayHeldCandidates; } });
 Object.defineProperty(exports, "clearRelayPending", { enumerable: true, get: function () { return relay_bind_db_2.clearRelayPending; } });
 Object.defineProperty(exports, "clearRelayPendingReply", { enumerable: true, get: function () { return relay_bind_db_2.clearRelayPendingReply; } });
+Object.defineProperty(exports, "clearRelayPendingReplyUnlessHeld", { enumerable: true, get: function () { return relay_bind_db_2.clearRelayPendingReplyUnlessHeld; } });
+Object.defineProperty(exports, "completeRelayPayloadDelivery", { enumerable: true, get: function () { return relay_bind_db_2.completeRelayPayloadDelivery; } });
+Object.defineProperty(exports, "countHeldRelays", { enumerable: true, get: function () { return relay_bind_db_2.countHeldRelays; } });
+Object.defineProperty(exports, "completeRelayPromptDelivery", { enumerable: true, get: function () { return relay_bind_db_2.completeRelayPromptDelivery; } });
 Object.defineProperty(exports, "explainRelayBindRefusal", { enumerable: true, get: function () { return relay_bind_db_2.explainRelayBindRefusal; } });
 Object.defineProperty(exports, "failOrphanedRelayBind", { enumerable: true, get: function () { return relay_bind_db_2.failOrphanedRelayBind; } });
 Object.defineProperty(exports, "getRelayBinding", { enumerable: true, get: function () { return relay_bind_db_2.getRelayBinding; } });
 Object.defineProperty(exports, "getRelayPendingPayload", { enumerable: true, get: function () { return relay_bind_db_2.getRelayPendingPayload; } });
+Object.defineProperty(exports, "holdRelayPayloadDelivery", { enumerable: true, get: function () { return relay_bind_db_2.holdRelayPayloadDelivery; } });
+Object.defineProperty(exports, "isCurrentRelayPayloadAttempt", { enumerable: true, get: function () { return relay_bind_db_2.isCurrentRelayPayloadAttempt; } });
+Object.defineProperty(exports, "listDeliverableRelayPayloads", { enumerable: true, get: function () { return relay_bind_db_2.listDeliverableRelayPayloads; } });
 Object.defineProperty(exports, "listOpenBoundRelays", { enumerable: true, get: function () { return relay_bind_db_2.listOpenBoundRelays; } });
+Object.defineProperty(exports, "listRelaysWithDeliveryHold", { enumerable: true, get: function () { return relay_bind_db_2.listRelaysWithDeliveryHold; } });
 Object.defineProperty(exports, "listRelaysWithPendingPayload", { enumerable: true, get: function () { return relay_bind_db_2.listRelaysWithPendingPayload; } });
 Object.defineProperty(exports, "promoteRelayPendingReply", { enumerable: true, get: function () { return relay_bind_db_2.promoteRelayPendingReply; } });
 Object.defineProperty(exports, "recordRelayInputBoundary", { enumerable: true, get: function () { return relay_bind_db_2.recordRelayInputBoundary; } });
+Object.defineProperty(exports, "recoverInterruptedRelayDeliveries", { enumerable: true, get: function () { return relay_bind_db_2.recoverInterruptedRelayDeliveries; } });
+Object.defineProperty(exports, "recoverInterruptedRelayDeliveryRefs", { enumerable: true, get: function () { return relay_bind_db_2.recoverInterruptedRelayDeliveryRefs; } });
+Object.defineProperty(exports, "releaseRelayPayloadDelivery", { enumerable: true, get: function () { return relay_bind_db_2.releaseRelayPayloadDelivery; } });
+Object.defineProperty(exports, "RELAY_DELIVERY_SERVER_RESTARTED", { enumerable: true, get: function () { return relay_bind_db_2.RELAY_DELIVERY_SERVER_RESTARTED; } });
 Object.defineProperty(exports, "replaceRelayPromptWithPendingReply", { enumerable: true, get: function () { return relay_bind_db_2.replaceRelayPromptWithPendingReply; } });
 Object.defineProperty(exports, "replaceRelayPromptWithReply", { enumerable: true, get: function () { return relay_bind_db_2.replaceRelayPromptWithReply; } });
 Object.defineProperty(exports, "reserveRelayBind", { enumerable: true, get: function () { return relay_bind_db_2.reserveRelayBind; } });
@@ -58,7 +67,17 @@ Object.defineProperty(exports, "setRelayHold", { enumerable: true, get: function
 Object.defineProperty(exports, "setRelayPendingReply", { enumerable: true, get: function () { return relay_bind_db_2.setRelayPendingReply; } });
 Object.defineProperty(exports, "settleRelaySendState", { enumerable: true, get: function () { return relay_bind_db_2.settleRelaySendState; } });
 Object.defineProperty(exports, "stashRelayPayload", { enumerable: true, get: function () { return relay_bind_db_2.stashRelayPayload; } });
-const logger = (0, logger_1.createLogger)('relay-db');
+// Issue #4096: split out of this file; re-exported so every caller (and every
+// `vi.mock`) keeps this module's surface.
+var relay_db_base_1 = require("../../lib/db/relay-db-base");
+Object.defineProperty(exports, "getRelayById", { enumerable: true, get: function () { return relay_db_base_1.getRelayById; } });
+var relay_db_delivery_1 = require("../../lib/db/relay-db-delivery");
+Object.defineProperty(exports, "completeRelayReplyDelivery", { enumerable: true, get: function () { return relay_db_delivery_1.completeRelayReplyDelivery; } });
+Object.defineProperty(exports, "markRelayDelivered", { enumerable: true, get: function () { return relay_db_delivery_1.markRelayDelivered; } });
+var relay_db_hold_1 = require("../../lib/db/relay-db-hold");
+Object.defineProperty(exports, "resolveRelayDeliveryHold", { enumerable: true, get: function () { return relay_db_hold_1.resolveRelayDeliveryHold; } });
+var relay_db_count_1 = require("../../lib/db/relay-db-count");
+Object.defineProperty(exports, "countRelays", { enumerable: true, get: function () { return relay_db_count_1.countRelays; } });
 /** Insert a new `pending` relay and hand it back. */
 function createRelay(db, input) {
     const id = (0, crypto_1.randomUUID)();
@@ -93,15 +112,9 @@ function createRelay(db, input) {
         obsState: null,
         holdReason: null,
         overlap: null,
+        deliveryHold: null,
     };
 }
-/** One relay by id, or null. */
-function getRelayById(db, id) {
-    const row = db
-        .prepare(`SELECT ${relay_bind_db_1.RELAY_COLUMNS} FROM session_relays WHERE id = ?`)
-        .get(id);
-    return row ? (0, relay_bind_db_1.mapRelay)(row) : null;
-}
 /** Every still-open relay this session must answer (it is the `to` end). */
 function listOpenRelaysTo(db, endpoint) {
     const rows = db
@@ -163,47 +176,6 @@ function countOpenRelaysBetween(db, from, to) {
         .get(from.worktreeId, from.instanceId, to.worktreeId, to.instanceId, ...types_1.OPEN_RELAY_STATES);
     return row.n;
 }
-/**
- * Close the relay as delivered, exactly once.
- *
- * Two clauses, and they guard different things — worth separating, because a
- * later reader who notices that the second is redundant *for one relay id* will
- * otherwise delete the one that is not.
- *
- *  - `state IN (open)` is what makes a SECOND call for the same relay answer
- *    false: the first call left it `delivered`, which is not an open state.
- *  - `sent_request_id IS NULL`, together with the column's UNIQUE index, is what
- *    makes the delivery id itself unrepeatable ACROSS relays and across
- *    processes. It is the idempotency key the Issue names, and it is why this
- *    function catches: the index refusing a write is the answer "somebody else
- *    got there first", and that answer must not arrive as an exception inside a
- *    delivery path.
- *
- * @returns Whether this call is the one that closed it
- */
-function markRelayDelivered(db, id, sentRequestId, now = Date.now()) {
-    try {
-        const result = db
-            .prepare(`
-        UPDATE session_relays
-        SET state = 'delivered', sent_request_id = ?, delivered_at = ?,
-            pending_kind = NULL, pending_body = NULL, payload_id = NULL, updated_at = ?
-        WHERE id = ? AND sent_request_id IS NULL
-          AND state IN (${relay_bind_db_1.OPEN_STATE_PLACEHOLDERS})
-      `)
-            .run(sentRequestId, now, now, id, ...types_1.OPEN_RELAY_STATES);
-        return result.changes === 1;
-    }
-    catch (error) {
-        // The UNIQUE index refusing the write IS the answer "somebody else got
-        // there first", and it must not become an exception in a delivery path.
-        logger.warn('relay-deliver-conflict', {
-            relayId: id,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return false;
-    }
-}
 /**
  * Note that A is being told B is waiting on a confirmation.
  *
@@ -256,51 +228,20 @@ function listExpiredOpenRelays(db, now = Date.now()) {
         .all(...types_1.OPEN_RELAY_STATES, now);
     return rows.map(relay_bind_db_1.mapRelay);
 }
-/** Withdraw a relay. Returns false when it was already closed or absent. */
+/**
+ * Withdraw a relay. Returns false when it was already closed or absent.
+ *
+ * Issue #4064: stops later deliveries only. A payload under a delivery hold
+ * (it may already be in A's composer) keeps its body, id and reason.
+ */
 function cancelRelay(db, id, now = Date.now()) {
     const result = db
         .prepare(`
       UPDATE session_relays
-      SET state = 'cancelled', pending_kind = NULL, pending_body = NULL, payload_id = NULL,
+      SET state = 'cancelled', ${relay_bind_db_1.KEEP_HELD_PAYLOAD_SET},
           pending_reply = NULL, updated_at = ?
       WHERE id = ? AND state IN (${relay_bind_db_1.OPEN_STATE_PLACEHOLDERS})
     `)
         .run(now, id, ...types_1.OPEN_RELAY_STATES);
     return result.changes === 1;
 }
-/**
- * Count relays per state.
- *
- * The shape `commandmate task show` and `report metrics` print. Counting in SQL
- * rather than reading rows because a long-lived server accumulates thousands
- * and both callers want five integers.
- */
-function countRelays(db, filter = {}) {
-    const clauses = [];
-    const params = [];
-    if (filter.worktreeId) {
-        if (filter.instanceId) {
-            clauses.push('((from_worktree_id = ? AND from_instance_id = ?) OR (to_worktree_id = ? AND to_instance_id = ?))');
-            params.push(filter.worktreeId, filter.instanceId, filter.worktreeId, filter.instanceId);
-        }
-        else {
-            clauses.push('(from_worktree_id = ? OR to_worktree_id = ?)');
-            params.push(filter.worktreeId, filter.worktreeId);
-        }
-    }
-    if (filter.since !== undefined) {
-        clauses.push('created_at >= ?');
-        params.push(filter.since);
-    }
-    const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
-    const rows = db
-        .prepare(`SELECT state, COUNT(*) AS n FROM session_relays ${where} GROUP BY state`)
-        .all(...params);
-    const counts = (0, types_1.emptyRelayCounts)();
-    for (const row of rows) {
-        if (row.state in counts) {
-            counts[row.state] = row.n;
-        }
-    }
-    return counts;
-}

package/dist/server/src/lib/detection/tools/opencode/composer-own-text.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * The text an opencode input box holds, cut out of the rows it shares with the
+ * sidebar (Issue #4067).
+ *
+ * opencode (v1, and v2 2.0.x — same box: `┃` gutter rows over a `╹▀…▀` bottom
+ * border) draws its sidebar (#2047/#2095) on the same rows as the input box,
+ * right of the box's bottom border: measured in `opencode-live-2047/w200/`
+ * (border to column 156, sidebar from 160), `opencode-live-2046/w80/sidebar-on.txt`
+ * and `opencode-v2-usage-2981/pane-turn1-2.0.18.txt`. A row's own text is what
+ * lies left of that border's end, its gutter removed.
+ *
+ * Before #4067 there were two readings of the same rows: the send readiness
+ * (#4040) cut at the right edge, and the submit read-back
+ * (`submit-composer-read`'s `opencode-box`) read the whole row — so an empty box
+ * beside the sidebar was ready to the one and held `/private/…` (the sidebar's
+ * working directory) to the other, which then classified a delivered message
+ * `replaced`. Both now read through this module.
+ *
+ * Text inside the box is the buffer however far it is indented (`┃    old` is
+ * not empty).
+ *
+ * @module lib/detection/tools/opencode/composer-own-text
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeBoxRightEdge = opencodeBoxRightEdge;
+exports.opencodeBoxObscured = opencodeBoxObscured;
+exports.opencodeOwnText = opencodeOwnText;
+exports.readOpenCodeComposerOwnRows = readOpenCodeComposerOwnRows;
+exports.readOpenCodeComposerBox = readOpenCodeComposerBox;
+const terminal_columns_1 = require("../../terminal-columns");
+const patterns_1 = require("./patterns");
+/** The input box's bottom border row (`╹▀…▀`), the newest one on the pane, or `null`. */
+function bottomBorderRow(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (patterns_1.OPENCODE_COMPOSER_BOTTOM_BORDER.test(lines[i]))
+            return lines[i];
+    }
+    return null;
+}
+/**
+ * The column just right of the input box: the end of its bottom border
+ * (`╹▀…▀`), the newest one on the pane. `null` when there is none.
+ *
+ * The end of the border's FIRST run: on a border an overlay cuts in two
+ * ({@link opencodeBoxObscured}) that is where the overlay starts, not the box's
+ * right edge.
+ *
+ * @param lines - Captured pane lines, ANSI-stripped, box drawing intact
+ */
+function opencodeBoxRightEdge(lines) {
+    const row = bottomBorderRow(lines);
+    if (row === null)
+        return null;
+    const border = /╹▀+/.exec(row);
+    return border ? border.index + border[0].length : null;
+}
+/**
+ * Whether something is drawn over the input box: its bottom border is cut in
+ * two — `╹▀▀▀▀▀▀`, blanks, then `▀▀▀▀▀▀▀▀` further right (review of #4067).
+ * A palette or picker (`opencode-live-2049/command-palette-11822.txt`,
+ * `opencode-live-1896/command-palette.txt`, `canary/opencode-picker.raw.txt`)
+ * paints over the box's rows from that cut on, so what the box holds there
+ * cannot be read: neither an empty box nor the absence of one. No capture with
+ * a whole box has a `▀` right of its border's first run (the sidebar's rows
+ * included: every `.txt` capture under `tests/` was checked).
+ *
+ * @param lines - Captured pane lines, ANSI-stripped, box drawing intact
+ */
+function opencodeBoxObscured(lines) {
+    const row = bottomBorderRow(lines);
+    if (row === null)
+        return false;
+    const border = /╹▀+/.exec(row);
+    return border !== null && row.includes('▀', border.index + border[0].length);
+}
+/**
+ * The row's own text: inside the box (left of `rightEdge`), gutter removed.
+ * With no right edge (no border found) the whole row is read, as before #4067.
+ *
+ * @param row - One composer row, gutter intact
+ * @param rightEdge - {@link opencodeBoxRightEdge} of the same frame
+ */
+function opencodeOwnText(row, rightEdge) {
+    const inside = rightEdge === null ? row : row.slice(0, (0, terminal_columns_1.indexAtColumn)(row, rightEdge));
+    return (0, patterns_1.stripOpenCodeGutter)(inside);
+}
+/**
+ * The input box's buffer rows as their own text (gutter and sidebar removed),
+ * or `null` when no box is on screen ({@link findOpenCodeComposerRows}).
+ *
+ * @param lines - Captured pane lines of the WHOLE pane, ANSI-stripped
+ */
+function readOpenCodeComposerOwnRows(lines) {
+    const rows = (0, patterns_1.findOpenCodeComposerRows)(lines);
+    if (rows === null)
+        return null;
+    const rightEdge = opencodeBoxRightEdge(lines);
+    return rows.map((row) => opencodeOwnText(row, rightEdge));
+}
+/**
+ * The input box as the submit read-back reads it: its rows' own text, and
+ * whether an overlay hides part of it. `null` when no box is on screen.
+ *
+ * @param lines - Captured pane lines of the WHOLE pane, ANSI-stripped
+ */
+function readOpenCodeComposerBox(lines) {
+    const rows = (0, patterns_1.findOpenCodeComposerRows)(lines);
+    if (rows === null)
+        return null;
+    if (!opencodeBoxObscured(lines)) {
+        const rightEdge = opencodeBoxRightEdge(lines);
+        return { rows: rows.map((row) => opencodeOwnText(row, rightEdge)), obscured: false };
+    }
+    const border = bottomBorderRow(lines);
+    // A column, like the right edge: the overlay's text on the border row may be wide.
+    const farEdge = (0, terminal_columns_1.visibleWidth)(border.slice(0, border.lastIndexOf('▀') + 1));
+    return { rows: rows.map((row) => opencodeOwnText(row, farEdge)), obscured: true };
+}

package/dist/server/src/lib/detection/tools/opencode/readiness.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Whether an opencode (v1) pane is ready to take a typed message body
+ * (Issue #4040).
+ *
+ * The launch wait (`OpenCodeTool.waitForReady`) is not this test: it accepts
+ * the `Connect a provider` overlay so a launch does not burn its window there,
+ * and `OPENCODE_IDLE_COMPOSER_PATTERN` only anchors the placeholder's start —
+ * it does not say the rest of the input box is empty, and opencode stops
+ * painting the placeholder once a session has answered a turn (every
+ * post-turn frame in `tests/fixtures/opencode-live-2047/w80/` has an input box
+ * of blank gutter rows and no `Ask anything`).
+ *
+ * Ready means, on the WHOLE frame (the box is centred under the banner until
+ * the first turn, ~100 rows above the bottom):
+ *
+ * - no dialog or overlay — the detector's `waiting` (permission strip, picker,
+ *   palette, `Connect a provider`) and the picker header itself;
+ * - the input box is on screen (`findOpenCodeComposerRows`: its bottom border
+ *   and gutter);
+ * - every buffer row of it is empty: blank, or the placeholder (optionally with
+ *   its quoted suggestion) and nothing else. A row holding any other text —
+ *   a previous body, a typed character — is not ready.
+ *
+ * A turn being generated keeps the empty box on screen (`turn-running.txt`),
+ * so it is ready by the same rule; no generation exception is needed.
+ *
+ * Text right of the box is not read as the row's own: the sidebar
+ * (#2047/#2095) shares rows with the input box, beyond the right end of the
+ * box's bottom border (`╹▀…▀`, measured in `opencode-live-2047/w200/`: border
+ * to column 156, sidebar from 160). Text inside the box is the buffer however
+ * far it is indented (`┃    old` is not empty), as `submit-composer-read`'s
+ * `opencode-box` reader reads it — both through `composer-own-text` (#4067).
+ *
+ * @module lib/detection/tools/opencode/readiness
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOpenCodeComposerReady = isOpenCodeComposerReady;
+const ansi_1 = require("../../ansi");
+const status_detector_1 = require("../../status-detector");
+const patterns_1 = require("./patterns");
+const composer_own_text_1 = require("./composer-own-text");
+/** The placeholder opencode paints in an empty buffer, with its quoted suggestion. */
+const PLACEHOLDER = /^Ask anything(?:\.\.\.|…)(?:[^\S\n]+"[^"\n]*")?$/;
+/**
+ * @param output - Raw `capture-pane` output of the whole pane (ANSI allowed)
+ * @returns true when the input box is on screen, empty, and nothing covers it
+ */
+function isOpenCodeComposerReady(output) {
+    const text = (0, ansi_1.stripAnsi)(output);
+    if (patterns_1.OPENCODE_SELECTION_LIST_PATTERN.test(text))
+        return false;
+    const status = (0, status_detector_1.detectSessionStatus)(output, 'opencode');
+    if (status.hasActivePrompt || status.status === 'waiting')
+        return false;
+    // Each row's own text, cut at the box's right edge (Issue #4067: the same
+    // cut the submit read-back uses — `composer-own-text`).
+    const rows = (0, composer_own_text_1.readOpenCodeComposerOwnRows)(text.split('\n'));
+    if (rows === null || rows.length === 0)
+        return false;
+    return rows.every((own) => own === '' || PLACEHOLDER.test(own));
+}