commandmate 0.49.0 → 0.49.1

package/dist/cli/commands/ask.js

@@ -135,10 +135,12 @@ async function readLatestReply(client, worktreeId, instanceId, since, cliToolId)
         // The rules are `reply`'s too (Issue #3039). A tool with no transcript
         // takes the newest row after the send, marker or not, with no wait.
         const reply = (0, reply_ledger_1.pickLatestReply)((0, reply_ledger_1.replyCandidates)(messages ?? [], since), requireTurnRow);
+        // The rows go back with the answer so the overlap check (Issue #3955)
+        // reads the same ledger the reply came from, with no request of its own.
         if (reply)
-            return reply.content;
+            return { content: reply.content, messages };
         if (!requireTurnRow || Date.now() >= deadline)
-            return null;
+            return { content: null, messages };
         await sleep(REPLY_TURN_ROW_POLL_MS);
     }
 }
@@ -222,7 +224,8 @@ function reportWaitFailure(result, worktreeId, instanceId, agent, options) {
 /** Reads the reply from the transcript, falling back to the pane. */
 async function readAskReply(client, worktreeId, instanceId, askedAt, agent) {
     let source = 'history';
-    let reply = await readLatestReply(client, worktreeId, instanceId, askedAt, agent);
+    const latest = await readLatestReply(client, worktreeId, instanceId, askedAt, agent);
+    let reply = latest.content;
     if (reply === null && agent) {
         source = 'pane';
         const pane = await readPaneTail(client, worktreeId, agent, instanceId);
@@ -232,17 +235,126 @@ async function readAskReply(client, worktreeId, instanceId, askedAt, agent) {
     if (reply === null) {
         source = 'none';
     }
-    return { source, reply };
+    return { source, reply, messages: latest.messages };
+}
+/**
+ * Whether this ask's turn was shared with another message (Issue #3955).
+ *
+ * codex 0.164.0 folds a message typed while a turn is running into that turn
+ * ("Messages to be submitted after next tool call") and answers both with one
+ * reply, so two overlapping asks to one instance both exit 0 and one of them
+ * prints the other's answer (UAT 2026-10-27: 3 runs out of 4). Which reply
+ * belongs to which message is not on the wire, so this does not try to
+ * attribute it; it says the reply may not be this ask's.
+ *
+ * Both sides of the overlap, from records `ask` already reads:
+ *
+ * - the later ask: the send API's `turnOpenAtSend` (Issue #3957) — whether a
+ *   turn was open at the moment the body started going in, read on the server
+ *   at that moment. When the key is there its value alone decides this side:
+ *   it does not depend on the record a poll sees (the server publishes only
+ *   the newest one, and a turn opening right after the send replaces it before
+ *   the first poll), and `askedAt` is earlier than the input, so a turn that
+ *   closed in between is not this message's. Without the key ("not known": a
+ *   tool whose hooks report no turn start, an older server), a turn that
+ *   opened before `askedAt` and had not closed by
+ *   it — the turn `wait` adopted, or any turn record a poll saw (`wait` drops a
+ *   closed turn that opened more than one poll interval before it started, so
+ *   a turn that closed before this ask's first poll is only in the record).
+ *   Only a tool whose hooks report turns publishes one, and a turn that had
+ *   closed before the send does not count, so a plain ask never sees it;
+ * - the earlier ask: a `user` row with other text on the same instance sits
+ *   between this ask's own input and the end of the turn. The lower bound is
+ *   the row the send API returned (`foreignSince`, the server's stamp of the
+ *   input start), so a request that went in and was answered while this one
+ *   waited for the input lock is not counted (Issue #3957); `askedAt` when the
+ *   send did not say. The upper bound is the server's close time when it
+ *   published one, else the moment the turn was seen to end, so a message sent
+ *   after the `Stop` (to the next turn) is not counted. With no instance
+ *   resolved for the send there is no "same instance", and this side is off.
+ *
+ * @returns The first reason that applies, or null
+ */
+function detectOverlap(input) {
+    if (input.turnOpenAtSend !== undefined) {
+        if (input.turnOpenAtSend)
+            return 'turn-already-open';
+    }
+    else {
+        const closedBeforeSend = input.turnClosedAt !== null && input.turnClosedAt < input.askedAt;
+        if (input.turnStartedAt !== null && input.turnStartedAt < input.askedAt && !closedBeforeSend) {
+            return 'turn-already-open';
+        }
+        if (input.openAtSend)
+            return 'turn-already-open';
+    }
+    if (input.messages
+        && input.instanceId !== null
+        && (0, reply_ledger_1.hasForeignPromptInWindow)(input.messages, input.message, input.foreignSince, input.until, input.instanceId)) {
+        return 'foreign-message';
+    }
+    return null;
+}
+/**
+ * The stamp of the row the send API wrote for this ask, in epoch ms, or null
+ * when the body carried none (an older server, a mocked send) (Issue #3957).
+ */
+function sentRowStamp(sent) {
+    if (typeof sent?.timestamp !== 'string')
+        return null;
+    const at = Date.parse(sent.timestamp);
+    return Number.isFinite(at) ? at : null;
+}
+/**
+ * Where this ask's turn ended, for the overlap window (Issue #3955): the
+ * server's close time when one is known and not before the send, else the
+ * moment the turn was seen to end. A message stamped later went to the next
+ * turn.
+ */
+function overlapWindowEnd(askedAt, turnEndedAt, closedAt) {
+    return closedAt !== null && closedAt >= askedAt ? Math.min(closedAt, turnEndedAt) : turnEndedAt;
+}
+/**
+ * The ledger rows the overlap check reads, and the instance it is about
+ * (Issue #3955).
+ *
+ * The reply read's rows, plus — when that read came back full of rows newer
+ * than the send, so a `user` row may have been cut off — every `user` row since
+ * the send, paged in its own requests. The reply read itself is left as it is.
+ * The instance is the one the send was resolved to, else the one the ledger
+ * shows this ask's own row on inside `[askedAt, until]`, else null — the same
+ * window the overlap is looked for in, so the same text sent to another
+ * instance after this turn ended cannot leave the instance undecided.
+ */
+async function readOverlapLedger(client, worktreeId, instanceId, message, askedAt, until, messages) {
+    let rows = messages;
+    if (rows && (0, reply_ledger_1.mayHaveDroppedRowsSince)(rows, askedAt)) {
+        const since = await (0, reply_ledger_1.fetchPromptRowsSince)(client, worktreeId, instanceId, askedAt);
+        if (since)
+            rows = [...rows, ...since];
+    }
+    const target = instanceId ?? (rows ? (0, reply_ledger_1.ownPromptInstance)(rows, message, askedAt, until) : null);
+    return { messages: rows, instanceId: target };
+}
+/** The one stderr line for an overlap (Issue #3955). */
+function formatOverlapWarning(reason, target) {
+    const what = reason === 'turn-already-open'
+        ? `${target} was already in a turn when this message was sent, so the reply may be that turn's`
+        : `another message reached ${target} during this turn, so the reply may answer it`;
+    return `overlapped: ${what} rather than this ask's (send one ask at a time per instance)`;
 }
 /** Prints the reply (or its JSON, or the no-reply warning). */
-function printAskReply(worktreeId, instanceId, agent, source, reply, options) {
+function printAskReply(worktreeId, instanceId, agent, source, reply, options, overlapped) {
     if (options.json) {
+        // `overlapped` only when it is true (Issue #3955): an ask that did not
+        // overlap prints exactly the payload it always did.
         console.log(JSON.stringify({
             worktreeId,
             instanceId: instanceId ?? null,
             cliToolId: agent ?? null,
             source,
             reply,
+            ...(overlapped ? { overlapped: true } : {}),
         }, null, 2));
     }
     else if (reply === null) {
@@ -291,6 +403,15 @@ Exit codes (wait's, unchanged; --async always exits 0 once the relay exists):
   21   nothing was running to ask
   124  timed out. Look with \`capture <id> --instance <id> --pane --tail 60\`
 
+Send one ask at a time to an instance (Issue #3955). A message sent while the
+instance is mid-turn can be folded into that turn (codex does), and the two
+asks then get one reply between them. When ask sees that, it still exits 0
+with the reply but prints \`overlapped: ...\` on stderr and --json adds
+"overlapped": true — the reply may answer the other message.
+--async relays (and send --reply-to) take only a turn that ended after the
+message went in, and note a proven overlap on the delivered reply's second line
+(\`[CommandMate relay] ... (overlap=later)\`); see \`relays --id <relay-id>\`.
+
 There is deliberately no --auto-yes: turning another session's Auto-Yes on is
 a decision about that session's guard rails, not part of asking it a question.
 `)
@@ -320,9 +441,9 @@ a decision about that session's guard rails, not part of asking it a question.
             // Issue #2377: registered BEFORE the send, so a session that answers
             // immediately cannot finish its turn in the window between the message
             // and the ledger row. A refusal exits 2 having sent nothing.
-            let relayId;
+            let relay;
             if (options.async) {
-                relayId = await (0, message_dispatch_1.registerRelayForMessage)(client, {
+                relay = await (0, message_dispatch_1.registerRelayForMessage)(client, {
                     worktreeId,
                     replyTo: options.replyTo ?? 'self',
                     instance: options.instance,
@@ -340,34 +461,78 @@ a decision about that session's guard rails, not part of asking it a question.
             // reaching the agent. Reported as a config error with the server's
             // own sentence: the answer is to look at that session, never to
             // re-send.
-            await (0, message_dispatch_1.postMessage)(client, worktreeId, sendBody, {
-                relayId,
+            // Issue #3957: a bound relay's id rides on the send (see `postMessage`).
+            const sent = await (0, message_dispatch_1.postMessage)(client, worktreeId, sendBody, {
+                relay,
                 promptWaitingFallback: `${worktreeId} is waiting on a prompt; the message was not sent.`,
             });
             // Issue #2377: the whole point of `--async`. Nothing is waited on, so
             // the caller's own turn ends here and the answer arrives later, in their
             // composer, as a `relay` row.
-            if (relayId) {
-                printAsyncAck(worktreeId, instanceId, agent, relayId, options);
+            if (relay) {
+                printAsyncAck(worktreeId, instanceId, agent, relay.id, options);
                 return;
             }
             console.error('Message sent. Waiting for the reply...');
             // `wait`'s own poller, with `wait`'s own defaults: --on-prompt is left
             // at `agent`, so a prompt ends this ask with exit 10 and the payload
             // rather than blocking until the timeout.
+            // Issue #3955: the turn `wait` settled on, for the overlap check.
+            const turn = { startedAt: null, closedAt: null };
+            // Every turn record a poll saw, adopted or not: whether one was open at
+            // the send, and the close time of the newest.
+            const record = { openAtSend: false, closedAt: null };
             const result = await (0, wait_1.pollWorktree)(client, worktreeId, {
                 timeout,
                 instance: instanceId,
                 token: options.token,
                 // Always on (Issue #3011): a turn that never ran must not read as a reply.
                 failOnUpstreamFault: true,
+                onTurnStart: (startedAt, closedAt) => {
+                    // The close time is kept from the first poll that saw this turn
+                    // closed; a later poll publishing a newer turn does not erase it.
+                    if (startedAt !== turn.startedAt)
+                        turn.closedAt = null;
+                    turn.startedAt = startedAt;
+                    if (closedAt !== null && turn.closedAt === null)
+                        turn.closedAt = closedAt;
+                },
+                onTurnRecord: (openedAt, closedAt) => {
+                    record.closedAt = closedAt;
+                    if (openedAt !== null && openedAt < askedAt && (closedAt === null || closedAt >= askedAt)) {
+                        record.openAtSend = true;
+                    }
+                },
             });
             if (result.exitCode !== types_1.WaitExitCode.SUCCESS) {
                 reportWaitFailure(result, worktreeId, instanceId, agent, options);
                 return;
             }
-            const { source, reply } = await readAskReply(client, worktreeId, instanceId, askedAt, agent);
-            printAskReply(worktreeId, instanceId, agent, source, reply, options);
+            // Taken before the reply grace: a message sent after the turn ended
+            // went to the next turn, and is not an overlap with this one.
+            const turnEndedAt = Date.now();
+            const { source, reply, messages } = await readAskReply(client, worktreeId, instanceId, askedAt, agent);
+            // Reported, not acted on (Issue #3955): the exit code and the reply
+            // stay as they are; the line says the reply may not be this ask's.
+            const until = overlapWindowEnd(askedAt, turnEndedAt, turn.closedAt ?? record.closedAt);
+            const ledger = await readOverlapLedger(client, worktreeId, instanceId, message, askedAt, until, messages);
+            const overlap = detectOverlap({
+                message,
+                askedAt,
+                until,
+                turnStartedAt: turn.startedAt,
+                turnClosedAt: turn.closedAt,
+                openAtSend: record.openAtSend,
+                // Issue #3957: the server's own reading at the input start, when it has one.
+                turnOpenAtSend: typeof sent?.turnOpenAtSend === 'boolean' ? sent.turnOpenAtSend : undefined,
+                foreignSince: sentRowStamp(sent) ?? askedAt,
+                instanceId: ledger.instanceId,
+                messages: ledger.messages,
+            });
+            if (overlap) {
+                console.error(formatOverlapWarning(overlap, instanceId ?? ledger.instanceId ?? agent ?? worktreeId));
+            }
+            printAskReply(worktreeId, instanceId, agent, source, reply, options, overlap !== null);
             process.exit(types_1.ExitCode.SUCCESS);
         }
         catch (error) {

package/dist/cli/commands/message-dispatch.d.ts

@@ -6,7 +6,9 @@
  * Kept in its own module (not in send.ts / ask.ts) because tests mock those
  * modules' internals; what differs per command is passed in as arguments.
  */
+import type { ChatMessage } from '../types/api-responses';
 import { ApiClient } from '../utils/api-client';
+import { type RegisteredRelay } from './relays';
 /**
  * Code the send API returns when the session is blocked on a prompt (Issue
  * #1708). Mirrors PROMPT_WAITING_CODE in src/lib/session/prompt-waiting-guard.ts;
@@ -22,15 +24,33 @@ export interface RegisterRelayForMessageInput {
     agent?: string;
     allowRelayChain?: boolean;
 }
-/** Resolve both endpoints and open the relay; returns the relay id. */
-export declare function registerRelayForMessage(client: ApiClient, input: RegisterRelayForMessageInput): Promise<string>;
+/** Resolve both endpoints and open the relay; returns its id and whether it is bound. */
+export declare function registerRelayForMessage(client: ApiClient, input: RegisterRelayForMessageInput): Promise<RegisteredRelay>;
 export interface PostMessageOptions {
-    relayId?: string;
+    /**
+     * The relay this message opened. When it is bound, its id is put on the
+     * send (`relayId`) and it is withdrawn only on a confirmed `not_sent`.
+     */
+    relay?: RegisteredRelay;
     /** Runs first when the post fails, before the relay is cancelled. */
     onFailure?: () => Promise<void>;
     /** Printed (after `Error: `) when PROMPT_WAITING carried no message body. */
     promptWaitingFallback: string;
 }
-/** Post the message; on failure cancel the relay and report PROMPT_WAITING. */
-export declare function postMessage(client: ApiClient, worktreeId: string, sendBody: Record<string, unknown>, options: PostMessageOptions): Promise<void>;
+/**
+ * What to tell the sender about resending a failed send, from the server's
+ * `sendOutcome` on the error (Issue #3992). Null when the error carries none
+ * (a send that named no bound relay, an older server) or says `sent`.
+ */
+export declare function describeFailedSendOutcome(error: unknown, worktreeId: string): string | null;
+/**
+ * Post the message; on failure cancel the relay and report PROMPT_WAITING.
+ *
+ * Issue #3957: a bound relay is withdrawn only when nothing reached the worker
+ * (`not_sent`). When that cannot be said the relay is left open, the message
+ * is NOT resent, and stderr names the relay and how to look it up.
+ *
+ * @returns The send API's body (Issue #3957: `ask` reads `turnOpenAtSend`)
+ */
+export declare function postMessage(client: ApiClient, worktreeId: string, sendBody: Record<string, unknown>, options: PostMessageOptions): Promise<ChatMessage>;
 //# sourceMappingURL=message-dispatch.d.ts.map

package/dist/cli/commands/message-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-dispatch.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/message-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,SAAS,EAAY,MAAM,qBAAqB,CAAC;AAQ1D;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,MAAM,WAAW,4BAA4B;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,uEAAuE;AACvE,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,MAAM,CAAC,CAajB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,6EAA6E;IAC7E,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED,+EAA+E;AAC/E,wBAAsB,WAAW,CAC/B,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CA2Bf"}
+{"version":3,"file":"message-dispatch.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/message-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAY,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAML,KAAK,eAAe,EACrB,MAAM,UAAU,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,MAAM,WAAW,4BAA4B;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,yFAAyF;AACzF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,eAAe,CAAC,CAa1B;AAED,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,6EAA6E;IAC7E,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAwCD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc3F;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,WAAW,CAAC,CA+CtB"}

package/dist/cli/commands/message-dispatch.js

@@ -10,6 +10,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROMPT_WAITING_CODE = void 0;
 exports.registerRelayForMessage = registerRelayForMessage;
+exports.describeFailedSendOutcome = describeFailedSendOutcome;
 exports.postMessage = postMessage;
 const types_1 = require("../types");
 const api_client_1 = require("../utils/api-client");
@@ -21,7 +22,7 @@ const relays_1 = require("./relays");
  * tmux/detection graph in for one string.
  */
 exports.PROMPT_WAITING_CODE = 'PROMPT_WAITING';
-/** Resolve both endpoints and open the relay; returns the relay id. */
+/** Resolve both endpoints and open the relay; returns its id and whether it is bound. */
 async function registerRelayForMessage(client, input) {
     const replyEndpoint = await (0, relays_1.resolveRelayEndpoint)(client, input.replyTo);
     const workerEndpoint = await (0, relays_1.resolveEndpointForWorktree)(client, input.worktreeId, input.instance, input.agent);
@@ -31,27 +32,112 @@ async function registerRelayForMessage(client, input) {
         allowRelayChain: input.allowRelayChain,
     });
 }
-/** Post the message; on failure cancel the relay and report PROMPT_WAITING. */
+function isSendOutcome(value) {
+    return value === 'sent' || value === 'not_sent' || value === 'unknown';
+}
+/**
+ * Work out what a failed send did to a bound relay (Issue #3957).
+ *
+ * The server's own `sendOutcome` when the answer carries one. A 409
+ * `RELAY_BIND_CONFLICT` is another attempt's relay — never withdrawn from
+ * here. A 4xx without one was refused before the relay was reserved: nothing
+ * was sent. No answer at all (a dropped connection, a 5xx from in between) is
+ * asked of `GET /api/relays/:id`; only `sent` and `failed` are taken from it,
+ * because a send still waiting for the input lock reads `awaiting` too.
+ */
+async function resolveBoundSendOutcome(client, relayId, error) {
+    if (error instanceof api_client_1.ApiError && error.statusCode !== undefined) {
+        if (error.apiCode === 'RELAY_BIND_CONFLICT')
+            return 'conflict';
+        const reported = error.payload?.sendOutcome;
+        if (isSendOutcome(reported))
+            return reported;
+        if (error.statusCode < 500)
+            return 'not_sent';
+    }
+    try {
+        const { relay } = await client.get(`/api/relays/${relayId}`);
+        if (relay.sendState === 'sent')
+            return 'sent';
+        if (relay.sendState === 'failed')
+            return 'not_sent';
+    }
+    catch {
+        // Not answerable either: the relay is left as it is.
+    }
+    return 'unknown';
+}
+/**
+ * What to tell the sender about resending a failed send, from the server's
+ * `sendOutcome` on the error (Issue #3992). Null when the error carries none
+ * (a send that named no bound relay, an older server) or says `sent`.
+ */
+function describeFailedSendOutcome(error, worktreeId) {
+    if (!(error instanceof api_client_1.ApiError))
+        return null;
+    const outcome = error.payload?.sendOutcome;
+    if (outcome === 'not_sent') {
+        return 'Note: the message was not sent (sendOutcome=not_sent); it is safe to send it again.';
+    }
+    if (outcome === 'unknown') {
+        return ('Note: whether the message was sent is not known (sendOutcome=unknown); '
+            + `check the pane first (\`commandmate capture ${worktreeId} --pane\`) and do not resend before that, `
+            + 'or it may arrive twice.');
+    }
+    return null;
+}
+/**
+ * Post the message; on failure cancel the relay and report PROMPT_WAITING.
+ *
+ * Issue #3957: a bound relay is withdrawn only when nothing reached the worker
+ * (`not_sent`). When that cannot be said the relay is left open, the message
+ * is NOT resent, and stderr names the relay and how to look it up.
+ *
+ * @returns The send API's body (Issue #3957: `ask` reads `turnOpenAtSend`)
+ */
 async function postMessage(client, worktreeId, sendBody, options) {
-    const { relayId } = options;
+    const { relay } = options;
+    const relayId = relay?.id;
+    const body = relay?.bound ? { ...sendBody, relayId: relay.id } : sendBody;
     try {
-        await client.post(`/api/worktrees/${worktreeId}/send`, sendBody);
+        const sent = await client.post(`/api/worktrees/${worktreeId}/send`, body);
+        if (relay?.bound && sent?.sendOutcome === 'unknown')
+            (0, relays_1.printRelayUnconfirmedNotice)(relay.id);
+        return sent;
     }
     catch (error) {
+        const outcome = relay?.bound ? await resolveBoundSendOutcome(client, relay.id, error) : null;
+        // The answer was lost on the way back, and the server says it went out.
+        if (outcome === 'sent') {
+            return { worktreeId, role: 'user', content: '', sendOutcome: 'sent' };
+        }
         if (options.onFailure) {
             await options.onFailure();
         }
         // A relay whose message never arrived can never be answered; leaving
         // it open would have the requester waiting 24h for a turn that was
         // never started.
-        if (relayId) {
+        if (relayId && (outcome === null || outcome === 'not_sent')) {
             await (0, relays_1.cancelRelayQuietly)(client, relayId);
         }
+        else if (relayId && outcome === 'unknown') {
+            // Issue #3992: the relay notice carries the "look before resending" hint.
+            (0, relays_1.printRelayUnconfirmedNotice)(relayId, worktreeId);
+        }
+        const promptWaiting = error instanceof api_client_1.ApiError && error.apiCode === exports.PROMPT_WAITING_CODE;
+        // Issue #3992: whether it may be sent again, as the server said — not on
+        // PROMPT_WAITING, whose own line says to answer the prompt first, and not
+        // when the relay notice above already said it.
+        if (!promptWaiting && !(relayId && outcome === 'unknown')) {
+            const resendNote = describeFailedSendOutcome(error, worktreeId);
+            if (resendNote !== null)
+                console.error(resendNote);
+        }
         // Issue #1708: the session is sitting on a prompt, so the message
         // would have been typed into the prompt's input line rather than
         // reaching the agent. Reported on its own so an unattended runner sees
         // "answer the prompt", not a generic HTTP failure.
-        if (error instanceof api_client_1.ApiError && error.apiCode === exports.PROMPT_WAITING_CODE) {
+        if (promptWaiting && error instanceof api_client_1.ApiError) {
             // The server's own sentence, not error.message: handleApiError maps a
             // bare 409 to "Unexpected HTTP status: 409", which says nothing about
             // what to do next.

package/dist/cli/commands/relays.d.ts

@@ -2,6 +2,7 @@
  * relays Command - the standing delegations this machine is holding (#2377)
  *
  *   commandmate relays [--worktree <id>] [--instance <id|alias>] [--json]
+ *   commandmate relays --id <relay-id> [--json]   (Issue #3957: one relay, open or closed)
  *   commandmate relays cancel <relay-id>
  *
  * ## Why a command and not a flag on `ls`
@@ -76,6 +77,17 @@ export interface RegisterRelayInput {
     to: RelayEndpointArg;
     allowRelayChain?: boolean;
 }
+/** A relay {@link registerRelay} opened (Issue #3957). */
+export interface RegisteredRelay {
+    id: string;
+    /**
+     * The server confirmed `bindMode: 'bound'`: the relay id goes on the send,
+     * and only that send's reply is delivered. False on an older server.
+     */
+    bound: boolean;
+}
+/** The one line an older server's relay gets on stderr (Issue #3957). */
+export declare const LEGACY_RELAY_NOTICE: string;
 /**
  * Open a relay, printing the server's own refusal and exiting 2 on one.
  *
@@ -83,10 +95,21 @@ export interface RegisterRelayInput {
  * change (drop the flag, cancel the other relay, stop forwarding), which is what
  * `CONFIG_ERROR` means everywhere else in this CLI.
  *
- * @returns The relay id
+ * Issue #3957: asks for `bind: true` and believes it only when the answer says
+ * `bindMode: 'bound'`. A server that does not know the flag answers without
+ * the key; the relay is then the legacy kind and its id is not sent along.
+ *
+ * @returns The relay id, and whether it is bound
  */
-export declare function registerRelay(client: ApiClient, input: RegisterRelayInput): Promise<string>;
+export declare function registerRelay(client: ApiClient, input: RegisterRelayInput): Promise<RegisteredRelay>;
 /** Withdraw a relay, best effort. Used when the send it accompanied failed. */
 export declare function cancelRelayQuietly(client: ApiClient, relayId: string): Promise<void>;
+/**
+ * Print where a relay whose send could not be confirmed stands (Issue #3957).
+ *
+ * The relay is left open — withdrawing it would drop a reply that may well be
+ * on its way — and the message is not resent, which could make it arrive twice.
+ */
+export declare function printRelayUnconfirmedNotice(relayId: string, worktreeId?: string): void;
 export declare function createRelaysCommand(): Command;
 //# sourceMappingURL=relays.d.ts.map

package/dist/cli/commands/relays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relays.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/relays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,OAAO,EAAE,SAAS,EAA+B,MAAM,qBAAqB,CAAC;AAgB7E;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,aAM9B,CAAC;AAEH,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,QAEiD,CAAC;AAE1F,yDAAyD;AACzD,eAAO,MAAM,6BAA6B,QAER,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CAyB3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,gBAAgB,CAAC,CA0B3B;AAED,wCAAwC;AACxC,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,IAAI,EAAE,gBAAgB,CAAC;IACvB,+BAA+B;IAC/B,EAAE,EAAE,gBAAgB,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,+EAA+E;AAC/E,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY1F;AAyBD,wBAAgB,mBAAmB,IAAI,OAAO,CAsI7C"}
+{"version":3,"file":"relays.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/relays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,OAAO,EAAE,SAAS,EAA+B,MAAM,qBAAqB,CAAC;AAgB7E;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,aAM9B,CAAC;AAEH,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,QAEiD,CAAC;AAE1F,yDAAyD;AACzD,eAAO,MAAM,6BAA6B,QAER,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CAyB3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,gBAAgB,CAAC,CA0B3B;AAED,wCAAwC;AACxC,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,IAAI,EAAE,gBAAgB,CAAC;IACvB,+BAA+B;IAC/B,EAAE,EAAE,gBAAgB,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,0DAA0D;AAC1D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,QAEkD,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,eAAe,CAAC,CAkB1B;AAED,+EAA+E;AAC/E,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY1F;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAWtF;AAwCD,wBAAgB,mBAAmB,IAAI,OAAO,CAuJ7C"}