commandmate 0.49.0 → 0.49.2

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

@@ -39,8 +39,9 @@
  * @module lib/relay/relay-delivery
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverBoundRelays = exports.findWorkerReply = void 0;
 exports.resetRelayDeliveryState = resetRelayDeliveryState;
-exports.findWorkerReply = findWorkerReply;
+exports.evaluateRelayAfterSend = evaluateRelayAfterSend;
 exports.notifyRelayTurnCompleted = notifyRelayTurnCompleted;
 exports.notifyRelayPromptWaiting = notifyRelayPromptWaiting;
 exports.sweepExpiredRelays = sweepExpiredRelays;
@@ -49,10 +50,13 @@ exports.runRelayMaintenanceTick = runRelayMaintenanceTick;
 const db_instance_1 = require("../../lib/db/db-instance");
 const relay_db_1 = require("../../lib/db/relay-db");
 const chat_db_1 = require("../../lib/db/chat-db");
-const models_1 = require("../../types/models");
 const model_change_push_notifier_1 = require("../../lib/push/model-change-push-notifier");
 const send_user_message_1 = require("../../lib/session/send-user-message");
 const relay_messages_1 = require("../../lib/relay/relay-messages");
+const relay_boot_1 = require("../../lib/relay/relay-boot");
+const relay_bound_reply_1 = require("../../lib/relay/relay-bound-reply");
+Object.defineProperty(exports, "findWorkerReply", { enumerable: true, get: function () { return relay_bound_reply_1.findWorkerReply; } });
+Object.defineProperty(exports, "recoverBoundRelays", { enumerable: true, get: function () { return relay_bound_reply_1.recoverBoundRelays; } });
 const relay_policy_1 = require("../../lib/relay/relay-policy");
 const relay_readiness_1 = require("../../lib/relay/relay-readiness");
 const relay_session_ref_1 = require("../../lib/relay/relay-session-ref");
@@ -62,81 +66,10 @@ const types_1 = require("../../lib/relay/types");
 const logger_1 = require("../../lib/logger");
 const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('relay-delivery');
-/**
- * How many assistant rows back the reply is looked for.
- *
- * A turn can write several rows (a narration then a summary), and the relay
- * wants the last one that is actually the agent talking. Bounded because an
- * unbounded read of a long-lived worktree's history is a large query for one
- * line of answer.
- */
-const REPLY_LOOKBACK_MESSAGES = 40;
+/** How many passes one pump makes when a pass promoted a reply (Issue #3957). */
+const PUMP_PASSES_MAX = 3;
 /** How many times the scrape path re-reads before it gives up on stability. */
 const SCRAPE_STABILITY_ATTEMPTS = 3;
-/**
- * The `request_id` shape a transcript reader mints for a finished turn.
- *
- * `claude-turn:<uuid>`, `codex-turn:<turn_id>`, `antigravity-turn:<id>`,
- * `command-code-turn:<id>` and opencode's `oc-turn:<message id>`. Matched as a
- * SHAPE rather than as a list of five literals for the reason `ask`'s copy of
- * this line gives (Issue #2386): the sixth reader lands INSIDE the filter
- * instead of silently outside it. A `:` cannot appear in any of the ids
- * themselves, so this cannot match a row that merely contains the text.
- *
- * Copied rather than imported, deliberately. `src/cli/commands/ask.ts` has the
- * same regexp, and importing it here would invert the dependency (lib reaching
- * into the CLI bundle); `AGENT_MARKDOWN_REQUEST_ID_PREFIXES` in
- * `src/types/agent-transcript.ts` is the LIST form this shape is chosen not to
- * be. One regexp in each layer is cheaper than either edge.
- */
-const TURN_REQUEST_ID_PATTERN = /-turn:/;
-/**
- * Request-id namespaces CommandMate writes ABOUT a session, not for it.
- *
- * `chat_messages` has no `system` role, so "reply from X" (Issue #2377) and
- * "the model changed" (Issue #2357) are both stored as assistant rows and told
- * apart by their request id. Neither is a word the worker said, and handing the
- * relay's own notice back to the session it came from is the smallest possible
- * loop. `ask` steps over exactly these two for the same reason.
- */
-const SYSTEM_ROW_REQUEST_ID_PREFIXES = [
-    chat_db_1.RELAY_SYSTEM_REQUEST_ID_PREFIX,
-    chat_db_1.MODEL_CHANGE_REQUEST_ID_PREFIX,
-];
-/**
- * Whether this tool's reply is read out of a transcript rather than off a screen.
- *
- * For the six that answer `true` the ledger is authoritative: a row with no
- * turn marker was written by the SCRAPER, and for these tools a scraped row is
- * never the answer — it is a footer line, a half-drawn frame or the ANSI dump
- * the send path flushes (Issues #2398 / #2400). The relay may therefore hold
- * out for a marked row. For copilot, gemini and vibe-local the scraper's row is
- * the only record there will ever be, and demanding a marker would deliver
- * nothing, ever.
- *
- * A record and not a `Set`, so a ninth entry in `CLI_TOOL_IDS` fails `tsc` here
- * instead of quietly defaulting to "screen-scraped" — the idiom
- * `cli-tools/install-hints` uses for the same reason.
- *
- * Deliberately NOT `isPullTranscriptHistory`: that asks who does the READING,
- * so opencode (whose own server pushes) answers `false` even though its rows
- * carry `oc-turn:` like the other four. It also lives in `lib/polling`, whose
- * module graph reaches this file's triggers — importing it would close a cycle
- * the relay was built to avoid.
- */
-const TRANSCRIPT_READER_TOOLS = {
-    claude: true,
-    codex: true,
-    antigravity: true,
-    'command-code': true,
-    opencode: true,
-    copilot: false,
-    gemini: false,
-    'vibe-local': false,
-    // Issue #2940: OpenCode V2's replies are written from its server
-    // (`GET /api/session/{id}/message`) under `oc-turn:`, like opencode's.
-    'opencode-v2': true,
-};
 /**
  * How long the scrape path holds out for the transcript row.
  *
@@ -162,108 +95,75 @@ function resetRelayDeliveryState() {
     inFlight.clear();
     (0, relay_delivery_claims_1.resetRelayDeliveryClaims)();
     globalThis.__relayPumpRunning = false;
-}
-function senderLabel(db, relay) {
-    const worker = (0, relay_session_ref_1.resolveRelaySession)(db, relay.to);
-    return { alias: worker.alias, worktreeId: worker.worktreeId };
-}
-/** Whether a row's `request_id` says a transcript reader wrote it. */
-function isTurnRow(requestId) {
-    return typeof requestId === 'string' && TURN_REQUEST_ID_PATTERN.test(requestId);
-}
-/** Whether a row is CommandMate's own furniture rather than the worker's words. */
-function isSystemRow(requestId) {
-    return typeof requestId === 'string'
-        && SYSTEM_ROW_REQUEST_ID_PREFIXES.some((prefix) => requestId.startsWith(prefix));
-}
-/** Whether this worker's answer is only ever a transcript row. */
-function requiresTurnRow(cliToolId) {
-    return TRANSCRIPT_READER_TOOLS[cliToolId] === true;
+    globalThis.__relayRecoveredBootId = undefined;
 }
 /**
- * The newest thing B actually said, at or after `since`.
+ * The bound send was confirmed: judge what was held for it (Issue #3957).
  *
- * Four kinds of row are stepped over, and each exclusion is load-bearing:
- * prompt rows (a question is not an answer, and the confirmation notice is a
- * separate delivery), CommandMate's own system rows (delivering "Reply from X"
- * back to X is the smallest possible loop), empty bodies — and, for a tool that
- * keeps a transcript, every row the SCRAPER wrote.
+ * The EARLIEST turn at or after the boundary is taken — not the newest: when
+ * two turns ended before the send was confirmed, the first one after the
+ * boundary is the one this request started. It is re-read from the boundary
+ * (the held candidates are the record of what was seen, ordered by the same
+ * key), and the held list is dropped. The worker's open prompt is judged at the same moment: a dialog
+ * that appeared after the boundary and is still open is told now (its opening
+ * edge fired while the send was unconfirmed and will not fire again); one
+ * already answered is not.
  *
- * That last one is Issue #2401. Until it was added the filter looked only at
- * shape, never at provenance, so the newest row won whatever had written it:
- * a codex footer line, a partial scrape, or the raw ANSI the send path flushes
- * lands in the ledger with `request_id IS NULL` and, being newest, WAS the
- * reply — forwarded to the requesting agent as the worker's own answer, which
- * it then summarises. #2386 fixed the identical hole in `ask` by demanding the
- * turn marker; the relay looked exempt only because its 15-second pump usually
- * gave the transcript time to land, and a race the timing usually wins is still
- * a race.
+ * Never throws; called by the send route right after it settled the send.
  */
-function findWorkerReply(db, worker, since) {
-    const messages = (0, chat_db_1.getMessages)(db, worker.worktreeId, {
-        limit: REPLY_LOOKBACK_MESSAGES,
-        cliToolId: worker.cliToolId,
-        instanceId: worker.instanceId,
-        matchResolvedInstance: true,
-    });
-    const requireTurnRow = requiresTurnRow(worker.cliToolId);
-    // `getMessages` answers newest-first, so the first candidate IS the newest.
-    for (const message of messages) {
-        if (message.role !== 'assistant')
-            continue;
-        if (message.messageType === 'prompt')
-            continue;
-        if (isSystemRow(message.requestId))
-            continue;
-        if (requireTurnRow && !isTurnRow(message.requestId))
-            continue;
-        if (message.content.trim() === '')
-            continue;
-        return message.timestamp.getTime() < since ? null : message;
+function evaluateRelayAfterSend(relayId) {
+    try {
+        const db = (0, db_instance_1.getDbInstance)();
+        const binding = (0, relay_db_1.getRelayBinding)(db, relayId);
+        if (!binding)
+            return;
+        const { relay } = binding;
+        if (relay.sendState !== 'sent' || !(0, types_1.isOpenRelayState)(relay.state) || relay.inputBoundaryAt === null)
+            return;
+        const session = (0, relay_session_ref_1.resolveRelaySession)(db, relay.to);
+        const worker = {
+            worktreeId: session.worktreeId,
+            cliToolId: session.cliToolId,
+            instanceId: session.instanceId,
+        };
+        const boundary = relay.inputBoundaryAt;
+        const now = Date.now();
+        const decided = db.transaction(() => {
+            (0, relay_db_1.clearRelayHeldCandidates)(db, relayId);
+            if (!(0, relay_bound_reply_1.observationStillHolds)(db, worker, binding))
+                return false;
+            // Re-read from the boundary rather than trusting what was held: the
+            // held list was read from `createdAt` (before the boundary existed) and
+            // may have spent the scan's bound on rows before it. The order is the
+            // same key either way — each turn's first row.
+            const [first] = (0, relay_bound_reply_1.findWorkerCompletions)(db, worker, boundary);
+            return first ? (0, relay_bound_reply_1.stashBoundReply)(db, worker, binding, first.row, now) : false;
+        })();
+        const prompted = decided ? false : (0, relay_bound_reply_1.notifyPromptForRelay)(db, worker, relayId);
+        if (decided || prompted)
+            void pumpRelayDeliveries();
     }
-    return null;
-}
-/** The options of B's open dialog, in the shape the notice lists them. */
-function promptOptionsOf(message) {
-    const data = message.promptData;
-    // #3184: type narrowing only — the stored row's screen `options` are listed;
-    // a stored degraded record never carries a decision id, so it has none.
-    if (!(0, models_1.isAnswerablePromptData)(data))
-        return [];
-    if (data.type === 'yes_no') {
-        return data.options.map((label) => ({ key: label, label }));
+    catch (error) {
+        logger.warn('relay-after-send-failed', {
+            relayId,
+            error: error instanceof Error ? error.message : String(error),
+        });
     }
-    return data.options.map((option) => ({
-        key: String(option.number),
-        label: option.label,
-    }));
 }
-/**
- * Stash B's finished reply against every relay that is waiting for it.
- *
- * @returns How many relays took a payload from this call
- */
-function stashReplyForOpenRelays(db, worker, now) {
-    const relays = (0, relay_db_1.listOpenRelaysTo)(db, {
-        worktreeId: worker.worktreeId,
-        instanceId: worker.instanceId,
-    });
-    if (relays.length === 0)
-        return 0;
-    let stashed = 0;
-    for (const relay of relays) {
-        // `createdAt` and not "the last time we looked": a reply written BEFORE the
-        // relay existed answered somebody else's question, and delivering it would
-        // hand session A the previous turn — the exact failure a bare `capture`
-        // after a `wait` has always had.
-        const reply = findWorkerReply(db, worker, relay.createdAt);
-        if (!reply)
-            continue;
-        const body = (0, relay_messages_1.buildRelayReplyMessage)(senderLabel(db, relay), reply.content);
-        if ((0, relay_db_1.stashRelayPayload)(db, relay.id, 'reply', body, now))
-            stashed += 1;
+/** {@link recoverBoundRelays}, once per boot. */
+function ensureRelayRecovery(db) {
+    const boot = (0, relay_boot_1.relayServerBootId)();
+    if (globalThis.__relayRecoveredBootId === boot)
+        return;
+    globalThis.__relayRecoveredBootId = boot;
+    try {
+        (0, relay_bound_reply_1.recoverBoundRelays)(db);
+    }
+    catch (error) {
+        logger.warn('relay-recovery-failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
     }
-    return stashed;
 }
 /** Sleep, so the scrape path can wait out its quiet window. */
 function sleep(ms) {
@@ -292,7 +192,7 @@ function sleep(ms) {
 async function deliverWhenTranscriptCatchesUp(db, worker) {
     const deadline = Date.now() + RELAY_TURN_ROW_GRACE_MS;
     for (;;) {
-        if (stashReplyForOpenRelays(db, worker, Date.now()) > 0) {
+        if ((0, relay_bound_reply_1.stashReplyForOpenRelays)(db, worker, Date.now()) > 0) {
             void pumpRelayDeliveries();
             return;
         }
@@ -324,7 +224,7 @@ async function notifyRelayTurnCompleted(worker, options) {
         if (waiting.length === 0)
             return;
         if (options.settled) {
-            if (stashReplyForOpenRelays(db, worker, Date.now()) > 0)
+            if ((0, relay_bound_reply_1.stashReplyForOpenRelays)(db, worker, Date.now()) > 0)
                 void pumpRelayDeliveries();
             return;
         }
@@ -333,7 +233,7 @@ async function notifyRelayTurnCompleted(worker, options) {
         // scraped row this announcement is about is not a candidate at all — the
         // relay waits for the marked one instead of watching an unmarked one hold
         // still (Issue #2401).
-        if (requiresTurnRow(worker.cliToolId)) {
+        if ((0, relay_bound_reply_1.requiresTurnRow)(worker.cliToolId)) {
             await deliverWhenTranscriptCatchesUp(db, worker);
             return;
         }
@@ -343,12 +243,12 @@ async function notifyRelayTurnCompleted(worker, options) {
         // this again anyway.
         let previousId = null;
         for (let attempt = 0; attempt < SCRAPE_STABILITY_ATTEMPTS; attempt += 1) {
-            const before = findWorkerReply(db, worker, 0);
+            const before = (0, relay_bound_reply_1.findWorkerReply)(db, worker, 0);
             previousId = before?.id ?? null;
             await sleep(relay_policy_1.RELAY_SCRAPE_QUIET_MS);
-            const after = findWorkerReply(db, worker, 0);
+            const after = (0, relay_bound_reply_1.findWorkerReply)(db, worker, 0);
             if ((after?.id ?? null) === previousId) {
-                if (stashReplyForOpenRelays(db, worker, Date.now()) > 0)
+                if ((0, relay_bound_reply_1.stashReplyForOpenRelays)(db, worker, Date.now()) > 0)
                     void pumpRelayDeliveries();
                 return;
             }
@@ -387,31 +287,11 @@ function notifyRelayPromptWaiting(worker) {
         const prompt = (0, chat_db_1.getLatestOpenPromptMessage)(db, worker.worktreeId, worker.cliToolId, worker.instanceId);
         if (!prompt)
             return;
-        const locale = (0, model_change_push_notifier_1.resolveReadersLocale)(db);
-        const options = promptOptionsOf(prompt);
-        // #3184: type narrowing only, to read `question` off the closed union.
-        const question = (0, models_1.isAnswerablePromptData)(prompt.promptData)
-            ? prompt.promptData.question
-            : (prompt.promptData?.question ?? prompt.content);
         let stashed = 0;
         for (const relay of relays) {
-            // The dialog's own row id is the signature: a wait that lasts twenty
-            // minutes is ONE row, so A is told once however many polls observe it.
-            if ((0, relay_db_1.getRelayPromptSignature)(db, relay.id) === prompt.id)
-                continue;
-            const body = (0, relay_messages_1.buildRelayPromptMessage)(locale, senderLabel(db, relay), {
-                question,
-                options,
-            });
-            if ((0, relay_db_1.stashRelayPayload)(db, relay.id, 'prompt', body)) {
-                // The signature is recorded HERE, before the delivery, and not after it:
-                // it is what stops every later poll of the same twenty-minute dialog
-                // from stashing the same notice again while A is still busy. The state
-                // moving to `prompt` is an OPEN state, so the reply that follows once
-                // the dialog is answered can still be stashed and delivered.
-                (0, relay_db_1.markRelayPromptNotified)(db, relay.id, prompt.id);
+            // Issue #3957: a bound relay is told only about a dialog of its own send.
+            if ((0, relay_bound_reply_1.stashPromptNotice)(db, worker, relay, prompt))
                 stashed += 1;
-            }
         }
         if (stashed > 0)
             void pumpRelayDeliveries();
@@ -445,9 +325,10 @@ function sweepExpiredRelays(db, now = Date.now()) {
             const locale = (0, model_change_push_notifier_1.resolveReadersLocale)(db);
             // A payload that never went out is superseded by the expiry notice: A
             // asked for an answer, and what they are getting is the news that there
-            // will not be one.
+            // will not be one. Both slots (Issue #3957).
             (0, relay_db_1.clearRelayPending)(db, relay.id, now);
-            const body = (0, relay_messages_1.buildRelayExpiredMessage)(locale, senderLabel(db, relay), relay.expiresAt - relay.createdAt);
+            (0, relay_db_1.clearRelayPendingReply)(db, relay.id, now);
+            const body = (0, relay_messages_1.buildRelayExpiredMessage)(locale, (0, relay_bound_reply_1.senderLabel)(db, relay), relay.expiresAt - relay.createdAt);
             const stashed = (0, relay_db_1.stashRelayPayload)(db, relay.id, 'expired', body, now);
             if (!(0, relay_db_1.markRelayExpired)(db, relay.id, now)) {
                 if (stashed)
@@ -496,7 +377,7 @@ async function deliverOne(db, relayId, kind, body) {
         return 'held';
     }
     // Synchronous from here to the send: re-read, then claim.
-    const current = findCurrentPayload(db, relayId);
+    const current = (0, relay_db_1.getRelayPendingPayload)(db, relayId);
     if (!current || current.kind !== kind || current.body !== body) {
         logger.info('relay-delivery-superseded', { relayId, kind });
         return 'skipped';
@@ -510,6 +391,7 @@ async function deliverOne(db, relayId, kind, body) {
     const relay = current.relay;
     const requester = (0, relay_session_ref_1.resolveRelaySession)(db, relay.from);
     (0, relay_delivery_claims_1.claimRelayDelivery)(relayId);
+    let delivered = false;
     try {
         const result = await (0, send_user_message_1.sendUserMessage)(db, {
             worktreeId: requester.worktreeId,
@@ -533,26 +415,49 @@ async function deliverOne(db, relayId, kind, body) {
                 // composer, which is the outcome that mattered.
                 logger.info('relay-already-closed-on-deliver', { relayId });
             }
-            (0, relay_system_line_1.writeRelaySystemLine)(db, relay.id, 'replied', requester, (0, relay_session_ref_1.resolveRelaySession)(db, relay.to), now);
+            (0, relay_system_line_1.writeRelaySystemLine)(db, relay.id, 'replied', requester, (0, relay_session_ref_1.resolveRelaySession)(db, relay.to), now, { overlap: relay.overlap, holdReason: relay.holdReason });
         }
         else if (kind === 'prompt') {
             (0, relay_system_line_1.writeRelaySystemLine)(db, relay.id, 'waiting', requester, (0, relay_session_ref_1.resolveRelaySession)(db, relay.to), now);
         }
-        (0, relay_db_1.clearRelayPending)(db, relay.id, now);
+        // Issue #3957: only the payload that was sent. A reply that replaced it
+        // or waits in the second slot survives, and the second slot is promoted
+        // now that the notice is out.
+        (0, relay_db_1.clearRelayPending)(db, relay.id, now, current.payloadId);
+        if (kind === 'prompt' && (0, relay_db_1.promoteRelayPendingReply)(db, relay.id, now)) {
+            globalThis.__relayPumpAgain = true;
+        }
         logger.info('relay-delivered', { relayId, kind, to: `${requester.worktreeId}/${requester.instanceId}` });
+        delivered = true;
         return 'delivered';
     }
     finally {
+        // Issue #3957: a prompt notice that did not go out (refused, failed,
+        // threw) is back to unclaimed — and a reply that finished while it was
+        // being typed waits in the second slot. The reply supersedes the notice
+        // exactly as it would have had it arrived a moment later.
+        // A failure here must not keep the claim below from being released: a
+        // claim left behind refuses every cancel and every expiry of the relay.
+        if (!delivered && kind === 'prompt') {
+            try {
+                if ((0, relay_db_1.replaceRelayPromptWithPendingReply)(db, relay.id, current.payloadId)) {
+                    logger.info('relay-prompt-superseded-after-failed-delivery', { relayId });
+                    globalThis.__relayPumpAgain = true;
+                }
+            }
+            catch (error) {
+                logger.warn('relay-prompt-supersede-failed', {
+                    relayId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
         // Delivered: a reply is closed now and a prompt notice leaves the relay
         // open on purpose, so either way a later cancel must be judged by the row.
         // Held or failed: nothing reached A, so the relay can be withdrawn again.
         (0, relay_delivery_claims_1.releaseRelayDelivery)(relayId);
     }
 }
-/** The payload this relay carries right now, read straight from the ledger. */
-function findCurrentPayload(db, relayId) {
-    return (0, relay_db_1.listRelaysWithPendingPayload)(db).find((item) => item.relay.id === relayId) ?? null;
-}
 /**
  * Deliver every stashed payload that can be delivered now.
  *
@@ -566,22 +471,30 @@ async function pumpRelayDeliveries() {
     globalThis.__relayPumpRunning = true;
     try {
         const db = (0, db_instance_1.getDbInstance)();
-        for (const item of (0, relay_db_1.listRelaysWithPendingPayload)(db)) {
-            if (inFlight.has(item.relay.id))
-                continue;
-            inFlight.add(item.relay.id);
-            try {
-                await deliverOne(db, item.relay.id, item.kind, item.body);
-            }
-            catch (error) {
-                logger.warn('relay-delivery-failed', {
-                    relayId: item.relay.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            finally {
-                inFlight.delete(item.relay.id);
+        ensureRelayRecovery(db);
+        // Issue #3957: a reply promoted out of the second slot during a pass is
+        // delivered by one more pass rather than waiting for the next tick.
+        for (let pass = 0; pass < PUMP_PASSES_MAX; pass += 1) {
+            globalThis.__relayPumpAgain = false;
+            for (const item of (0, relay_db_1.listRelaysWithPendingPayload)(db)) {
+                if (inFlight.has(item.relay.id))
+                    continue;
+                inFlight.add(item.relay.id);
+                try {
+                    await deliverOne(db, item.relay.id, item.kind, item.body);
+                }
+                catch (error) {
+                    logger.warn('relay-delivery-failed', {
+                        relayId: item.relay.id,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                finally {
+                    inFlight.delete(item.relay.id);
+                }
             }
+            if (!globalThis.__relayPumpAgain)
+                break;
         }
     }
     catch (error) {
@@ -596,6 +509,7 @@ async function pumpRelayDeliveries() {
 /** One tick of the background loop: sweep the deadlines, then deliver. */
 async function runRelayMaintenanceTick() {
     try {
+        ensureRelayRecovery((0, db_instance_1.getDbInstance)());
         sweepExpiredRelays((0, db_instance_1.getDbInstance)());
     }
     catch (error) {

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

@@ -28,9 +28,10 @@
  * @module lib/relay/relay-messages
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RELAY_HEADER_PREFIX = void 0;
+exports.RELAY_NOTE_PREFIX = exports.RELAY_HEADER_PREFIX = void 0;
 exports.buildRelayHeader = buildRelayHeader;
 exports.buildRelayReplyMessage = buildRelayReplyMessage;
+exports.buildRelayOverlapNote = buildRelayOverlapNote;
 exports.buildRelayPromptMessage = buildRelayPromptMessage;
 exports.buildRelayExpiredMessage = buildRelayExpiredMessage;
 exports.buildRelaySystemLine = buildRelaySystemLine;
@@ -63,12 +64,38 @@ function buildRelayHeader(sender) {
  * nothing" is information, and swallowing the delivery would leave A waiting on
  * a relay that has already closed.
  */
-function buildRelayReplyMessage(sender, reply) {
+function buildRelayReplyMessage(sender, reply, overlapNote = null) {
     const body = reply.trim();
+    // Issue #3957: the note goes on its own line between the header and the
+    // reply, so the header stays the first token and the reply stays verbatim.
+    if (overlapNote !== null) {
+        return `${buildRelayHeader(sender)}\n${overlapNote}\n${body === '' ? '(no reply body)' : body}`;
+    }
     return body === ''
         ? `${buildRelayHeader(sender)} (no reply body)`
         : `${buildRelayHeader(sender)} ${body}`;
 }
+/**
+ * The literal the overlap note starts with (Issue #3957). Fixed in both
+ * languages, so a reader can find the note without knowing the server's.
+ */
+exports.RELAY_NOTE_PREFIX = '[CommandMate relay]';
+const OVERLAP_NOTE_TEMPLATES = {
+    en: 'Note: this reply may have been processed in the same turn as another request (overlap={overlap}).',
+    ja: '注意: この返答は、別の依頼と同じターンで処理された可能性があります（overlap={overlap}）。',
+};
+/**
+ * The one-line note a delivered reply carries when it may share a turn with
+ * another request (Issue #3957), or null for `none` / not judged.
+ *
+ * A statement of fact, never an instruction: the line lands in another agent's
+ * composer, and "re-ask" or "discard" there would be acted on.
+ */
+function buildRelayOverlapNote(locale, overlap) {
+    if (overlap === null || overlap === 'none')
+        return null;
+    return `${exports.RELAY_NOTE_PREFIX} ${OVERLAP_NOTE_TEMPLATES[locale].replace('{overlap}', overlap)}`;
+}
 /** Collapse whitespace and clip, so a 40-line dialog is one readable line. */
 function squeeze(text, max) {
     const flat = text.replace(/\s+/g, ' ').trim();
@@ -139,6 +166,14 @@ const SYSTEM_TEMPLATES = {
  * Written into `chat_messages` exactly as the model-change row is (#2357), in
  * the readers' language, because a stored row cannot be re-rendered per viewer.
  */
-function buildRelaySystemLine(locale, kind, alias) {
-    return SYSTEM_TEMPLATES[locale][kind].replace('{alias}', alias);
+function buildRelaySystemLine(locale, kind, alias, detail = {}) {
+    const line = SYSTEM_TEMPLATES[locale][kind].replace('{alias}', alias);
+    // Issue #3957: what the delivery proved, as untranslated tokens a reader
+    // can grep for in either language.
+    const parts = [];
+    if (detail.overlap)
+        parts.push(`overlap=${detail.overlap}`);
+    if (detail.holdReason)
+        parts.push(`hold=${detail.holdReason}`);
+    return parts.length === 0 ? line : `${line} (${parts.join(', ')})`;
 }

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

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * What a bound relay can PROVE about sharing a turn with another request
+ * (Issue #3957).
+ *
+ * Two directions, judged from what the send recorded and what the worker's
+ * history holds — never from the reply's own text:
+ *
+ *  - **later** — a turn was already open on the worker when this request's
+ *    input began (`turn_open_at_send = 1`): the request may have been folded
+ *    into somebody else's turn.
+ *  - **earlier** — another input reached the same instance after this one
+ *    began and before the reply: somebody else's request may have been folded
+ *    into this one's turn.
+ *
+ * `earlier` is claimed only when it is proven. A user row's timestamp can be
+ * nudged for display ordering, and a transcript reader writes a second copy of
+ * this send's own prompt under another id (#2387), so a row counts only when
+ * it is not this send's row, does not carry this send's text, and was INSERTED
+ * before the reply row (SQLite's rowid order). Anything else in the window is
+ * "cannot tell", which makes the result `unknown` rather than `none` — PR 3
+ * makes the earlier side exact; PR 2 lets it miss rather than guess.
+ *
+ * @module lib/relay/relay-overlap
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.judgeRelayOverlap = judgeRelayOverlap;
+const chat_db_1 = require("../../lib/db/chat-db");
+const user_turn_recorder_1 = require("../../lib/history/user-turn-recorder");
+/** Whether another input provably arrived between the boundary and the reply. */
+function judgeEarlier(db, binding, worker, reply) {
+    const boundary = binding.relay.inputBoundaryAt;
+    if (boundary === null)
+        return 'ambiguous';
+    const replySeq = db
+        .prepare('SELECT rowid AS seq FROM chat_messages WHERE id = ?')
+        .get(reply.id);
+    if (!replySeq)
+        return 'ambiguous';
+    const rows = db
+        .prepare(`
+      SELECT id, content, rowid AS seq FROM chat_messages
+      WHERE worktree_id = ? AND role = 'user' ${chat_db_1.ACTIVE_FILTER}
+        AND COALESCE(cli_tool_id, 'claude') = ?
+        AND COALESCE(instance_id, cli_tool_id, 'claude') = ?
+        AND timestamp >= ? AND timestamp < ?
+    `)
+        .all(worker.worktreeId, worker.cliToolId, worker.instanceId, boundary, reply.timestamp.getTime());
+    const own = binding.inputMessageId ? (0, chat_db_1.getMessageById)(db, binding.inputMessageId) : null;
+    const ownText = own ? (0, user_turn_recorder_1.normalizeUserTurnContent)(own.content) : null;
+    let ambiguous = false;
+    for (const row of rows) {
+        if (row.id === binding.inputMessageId)
+            continue;
+        // Without this send's own text, no other row can be told from its echo.
+        if (ownText === null || (0, user_turn_recorder_1.normalizeUserTurnContent)(row.content) === ownText) {
+            ambiguous = true;
+            continue;
+        }
+        // Stamped before the reply but written after it: the order is not proven.
+        if (row.seq > replySeq.seq) {
+            ambiguous = true;
+            continue;
+        }
+        return 'proven';
+    }
+    return ambiguous ? 'ambiguous' : 'none';
+}
+/**
+ * Judge one reply against the relay's recorded send.
+ *
+ * `none` only when `later` was ruled out by a valid observation and nothing in
+ * the window could be another input; every other undecided case is `unknown`.
+ */
+function judgeRelayOverlap(db, binding, worker, reply) {
+    const { relay } = binding;
+    const later = relay.turnOpenAtSend === true;
+    const laterRuledOut = relay.turnOpenAtSend === false && relay.obsState === 'valid';
+    const earlier = judgeEarlier(db, binding, worker, reply);
+    if (later && earlier === 'proven')
+        return { overlap: 'both', basis: 'turn-open-at-send+foreign-input' };
+    if (later)
+        return { overlap: 'later', basis: 'turn-open-at-send' };
+    if (earlier === 'proven')
+        return { overlap: 'earlier', basis: 'foreign-input' };
+    if (laterRuledOut && earlier === 'none')
+        return { overlap: 'none', basis: 'no-open-turn+no-other-input' };
+    return {
+        overlap: 'unknown',
+        basis: laterRuledOut ? 'other-input-unproven' : 'turn-state-unknown',
+    };
+}