commandmate 0.46.0 → 0.46.1

package/dist/server/src/lib/hooks/sources/antigravity/history.js

@@ -524,6 +524,10 @@ async function captureAntigravityTranscriptTurn(target, capture = {}, report) {
         // what the promotion to "final" rests on.
         const instanceKey = keyOf(target);
         const stopAt = await resolveAntigravityStopAt(target);
+        // Issue #3705: the follow list below is this instance's, and a tick retired
+        // while the reads above ran no longer speaks for it. Nothing is written yet.
+        if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'antigravity-transcript-write-refused', 'follow-list'))
+            return false;
         const completions = new Map();
         for (const turn of built.turns) {
             completions.set(turn.stepIndex, (0, transcript_1.resolveAntigravityTurnCompletion)(turn, stopAt));
@@ -546,6 +550,9 @@ async function captureAntigravityTranscriptTurn(target, capture = {}, report) {
             });
         }
         const pending = await selectUnwrittenAntigravityTurns(target, built.turns);
+        // Issue #3705: `unsettledStepsFor` below may drop the follow list.
+        if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'antigravity-transcript-write-refused', 'follow-list'))
+            return false;
         const writtenTurns = built.turns.slice(0, built.turns.length - pending.turns.length);
         // Before anything is written: the rows that are already there (#2438). This
         // is deliberately ahead of the early return below, because "the newest turn
@@ -598,6 +605,11 @@ async function captureAntigravityTranscriptTurn(target, capture = {}, report) {
             // An unconfirmed one joins the follow list so that its conclusion is still
             // picked up once three later turns have pushed it out of #2438's window.
             if (captured) {
+                // Issue #3705: after the write's own `await`. The row is there (it was
+                // written while the tick still owned the key), so the answer is true;
+                // the follow list and the cursor are no longer this tick's to move.
+                if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'antigravity-transcript-write-refused', 'follow-list'))
+                    return captured;
                 noteUnsettledAntigravityTurn(target, instanceKey, turn, completions.get(turn.stepIndex) ?? (0, transcript_1.resolveAntigravityTurnCompletion)(turn, stopAt));
             }
         }
@@ -810,6 +822,10 @@ async function growAntigravityTurnRow(target, existing, rendered, path) {
         Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
         Promise.resolve().then(() => __importStar(require('../../../../lib/ws-server'))),
     ]);
+    // Issue #3705: by row id, so a retired tick would grow a row the successor —
+    // or the migration — has since taken over.
+    if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'antigravity-transcript-write-refused', 'grow'))
+        return false;
     updateMessageContent(getDbInstance(), existing.id, rendered.body);
     broadcastMessage('message_updated', {
         worktreeId: target.worktreeId,
@@ -866,6 +882,11 @@ async function refreshAntigravityTurnRows(target, candidates, path, follow) {
     const db = getDbInstance();
     let updated = 0;
     for (const turn of candidates) {
+        // Issue #3705: asked at the top of every pass — the first comes after the
+        // imports, every later one after the previous turn's grow — because both
+        // follow-list writes below come before this pass's own `await`.
+        if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'antigravity-transcript-write-refused', 'follow-list'))
+            break;
         // Issue #2443: the row lookup moved ahead of the writable check, because
         // the follow list is a statement about ROWS. A turn that is open again has a
         // row whose body is provisional by definition and must stay followed, and a
@@ -1067,6 +1088,13 @@ async function writeAntigravityTurn(target, turn, rendered, timestampMs, path, r
         await growAntigravityTurnRow(target, existing, rendered, path);
         return true;
     }
+    // Issue #3705: the last `await` (the imports) is behind us and the row and its
+    // broadcast follow with none between. A tick retired meanwhile writes no row
+    // under the instance it lost — the request id only stops the SAME row being
+    // written twice — and answers false: History does not hold the turn.
+    if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'antigravity-transcript-write-refused', 'reply-row')) {
+        return false;
+    }
     const message = createMessage(db, {
         worktreeId: target.worktreeId,
         role: 'assistant',

package/dist/server/src/lib/hooks/sources/claude/history.js

@@ -1238,6 +1238,13 @@ async function writeClaudeTurn(target, turn, rendered, timestampMs, path, report
         await growClaudeTurnRow(target, existing, rendered, path);
         return true;
     }
+    // Issue #3705: the last `await` (the imports) is behind us and the row and its
+    // broadcast follow with none between. A tick retired meanwhile writes no row
+    // under the instance it lost — the request id only stops the SAME row being
+    // written twice — and answers false: History does not hold the turn.
+    if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'claude-transcript-write-refused', 'reply-row')) {
+        return false;
+    }
     const message = createMessage(db, {
         worktreeId: target.worktreeId,
         role: 'assistant',

package/dist/server/src/lib/hooks/sources/codex/history.js

@@ -729,6 +729,13 @@ async function writeCodexTurn(target, turn, rendered, timestampMs, windowFacts,
             itemsInWindow: turn.items.length,
         });
     }
+    // Issue #3705: the last `await` (the imports) is behind us and the row and its
+    // broadcast follow with none between. A tick retired meanwhile writes no row
+    // under the instance it lost — the request id only stops the SAME row being
+    // written twice — and answers false: History does not hold the turn.
+    if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'codex-transcript-write-refused', 'reply-row')) {
+        return false;
+    }
     const message = createMessage(db, {
         worktreeId: target.worktreeId,
         role: 'assistant',

package/dist/server/src/lib/hooks/sources/command-code/history.js

@@ -765,6 +765,13 @@ async function writeCommandCodeTurn(target, turn, rendered, timestampMs, path, r
         await growCommandCodeTurnRow(target, existing, rendered, path);
         return true;
     }
+    // Issue #3705: the last `await` (the imports) is behind us and the row and its
+    // broadcast follow with none between. A tick retired meanwhile writes no row
+    // under the instance it lost — the request id only stops the SAME row being
+    // written twice — and answers false: History does not hold the turn.
+    if (!(0, transcript_history_1.mayReaderWrite)(target, logger, 'command-code-transcript-write-refused', 'reply-row')) {
+        return false;
+    }
     const message = createMessage(db, {
         worktreeId: target.worktreeId,
         role: 'assistant',

package/dist/server/src/lib/hooks/sources/transcript-history.js

@@ -41,6 +41,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mayReaderWrite = mayReaderWrite;
 exports.resolveAssistantTimestampMs = resolveAssistantTimestampMs;
 exports.nextTurnOpensAt = nextTurnOpensAt;
 exports.isReadableFile = isReadableFile;
@@ -51,6 +52,35 @@ exports.growTurnRowTo = growTurnRowTo;
 exports.refreshTurnRowsTo = refreshTurnRowsTo;
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
+const poller_owner_1 = require("../../../lib/polling/poller-owner");
+/**
+ * Whether the reader may still write for `target` now, logging the refusal when
+ * it may not (Issue #3705).
+ *
+ * Asked by every reader write — a reply row, its growth, a user row, its key,
+ * the follow list — after the last `await` before it and with none between it
+ * and the write. The question is the poller's (`mayActForAgentInstance`): only
+ * a response-poller tick whose chain was stopped (a stop, a restart past
+ * `STALLED_TICK_TIMEOUT`, a worktree-ID migration) and that is reading for its
+ * own instance is turned away. The Stop hook, a route and a tick reading for
+ * another instance write as before. Answering false writes nothing — the
+ * request id of a row makes a write idempotent, it does not make a retired
+ * tick's write right, and a grow or a key is not idempotent at all.
+ *
+ * @param refusedEvent - The tool's own log event for the refusal
+ * @param write - What was about to be written, for the log line
+ */
+function mayReaderWrite(target, logger, refusedEvent, write) {
+    if ((0, poller_owner_1.mayActForAgentInstance)(target))
+        return true;
+    logger.info(refusedEvent, {
+        worktreeId: target.worktreeId,
+        instanceId: target.instanceId ?? target.cliToolId,
+        generation: (0, poller_owner_1.currentPollerOwner)()?.generation,
+        write,
+    });
+    return false;
+}
 /**
  * When the assistant row for this turn is dated.
  *
@@ -213,6 +243,10 @@ async function growTurnRowTo(target, existing, rendered, path, logger, updatedEv
         Promise.resolve().then(() => __importStar(require('../../../lib/db'))),
         Promise.resolve().then(() => __importStar(require('../../../lib/ws-server'))),
     ]);
+    // Issue #3705: by row id, so a retired tick would grow a row the successor —
+    // or the migration — has since taken over.
+    if (!mayReaderWrite(target, logger, 'transcript-write-refused', 'grow'))
+        return false;
     updateMessageContent(getDbInstance(), existing.id, rendered.body);
     broadcastMessage('message_updated', {
         worktreeId: target.worktreeId,

package/dist/server/src/lib/log-manager.js

@@ -69,7 +69,8 @@ function getLogFilePath(worktreeId, cliToolId = 'claude') {
  * @param userMessage - User's message
  * @param claudeResponse - Claude's response
  * @param cliToolId - CLI tool ID (claude, codex, gemini)
- * @returns Path to the created log file
+ * @param options - See {@link CreateLogOptions}
+ * @returns Path to the created log file, or null when `options.mayWrite` refused it
  *
  * @example
  * ```typescript
@@ -81,7 +82,7 @@ function getLogFilePath(worktreeId, cliToolId = 'claude') {
  * );
  * ```
  */
-async function createLog(worktreeId, userMessage, claudeResponse, cliToolId = 'claude') {
+async function createLog(worktreeId, userMessage, claudeResponse, cliToolId = 'claude', options = {}) {
     await ensureLogDirectory(cliToolId);
     const logPath = getLogFilePath(worktreeId, cliToolId);
     const timestamp = (0, date_fns_1.format)(new Date(), 'yyyy-MM-dd HH:mm:ss');
@@ -105,6 +106,10 @@ async function createLog(worktreeId, userMessage, claudeResponse, cliToolId = 'c
     logContent += `### ${displayName}\n\n`;
     logContent += `${claudeResponse}\n\n`;
     logContent += `---\n\n`;
+    // Issue #3705: after the two awaits above and right before the write — the
+    // only place the caller's question can still be answered for this entry.
+    if (options.mayWrite && !options.mayWrite())
+        return null;
     await promises_1.default.writeFile(logPath, logContent, 'utf-8');
     return logPath;
 }

package/dist/server/src/lib/polling/auto-yes-enter-fallback-state.js

@@ -52,15 +52,29 @@ const lastEnterFallbacks = (0, global_state_1.getOrInitGlobal)('__autoYesEnterFa
 /**
  * Record that Auto-Yes sent its Enter to a screen.
  *
+ * Issue #3706: `sent.epoch` is the session epoch the Enter was decided for. The
+ * Enter's `send-keys` is awaited, and a new session begun meanwhile has already
+ * dropped the record ({@link beginEnterFallbackSession}); the old send coming
+ * back must not put one back about the new process. So a record whose epoch is
+ * no longer the current one is not written. Omitted, the current epoch is used.
+ *
  * @param at - Epoch ms; defaults to now. Overridable so tests are deterministic.
+ * @returns Whether the record was written
  */
 function recordEnterFallbackSent(worktreeId, cliToolId, instanceId, sent, at = Date.now()) {
-    lastEnterFallbacks.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const current = getEnterFallbackSessionEpoch(key);
+    const { epoch = current, ...rest } = sent;
+    if (epoch !== current)
+        return false;
+    lastEnterFallbacks.set(key, {
         outcome: 'sent',
-        ...sent,
+        ...rest,
         sentAt: at,
         at,
+        epoch,
     });
+    return true;
 }
 /**
  * Record that the screen the last Enter went to is still up. A no-op when there
@@ -77,7 +91,12 @@ function recordEnterFallbackNoEffect(worktreeId, cliToolId, instanceId, screenKe
 }
 /** @returns The last Enter for this session, or null when Auto-Yes never sent one. */
 function getLastEnterFallback(worktreeId, cliToolId, instanceId) {
-    return lastEnterFallbacks.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const record = lastEnterFallbacks.get(key);
+    // Issue #3706: a record of an earlier session says nothing about this one.
+    if (!record || record.epoch !== getEnterFallbackSessionEpoch(key))
+        return null;
+    return record;
 }
 /**
  * The record as published, judged against the prompt the payload carries.

package/dist/server/src/lib/polling/auto-yes-poller-state.js

@@ -8,8 +8,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.promptFrameKey = promptFrameKey;
 exports.warnOncePerFrame = warnOncePerFrame;
+exports.partialAnswerScreenKey = partialAnswerScreenKey;
+exports.getPartialAnswer = getPartialAnswer;
+exports.forgetPartialAnswer = forgetPartialAnswer;
+exports.forgetPartialAnswersByWorktree = forgetPartialAnswersByWorktree;
+exports.clearPartialAnswers = clearPartialAnswers;
+exports.beginSendAttempt = beginSendAttempt;
+exports.settleSendAttempt = settleSendAttempt;
+exports.hasMovedSendInFlight = hasMovedSendInFlight;
+exports.movePartialAnswers = movePartialAnswers;
 const prompt_key_1 = require("../detection/prompt-key");
 const logger_1 = require("../../lib/logger");
+const auto_yes_state_1 = require("../auto-yes-state");
+const global_state_1 = require("../global-state");
+const auto_yes_enter_fallback_state_1 = require("./auto-yes-enter-fallback-state");
 const logger = (0, logger_1.createLogger)('auto-yes-poller');
 /**
  * Issue #2995: what makes two ticks "the same prompt" for `warnOncePerFrame`.
@@ -50,3 +62,225 @@ function warnOncePerFrame(pollerState, frameKey, event, fields) {
     pollerState.lastSkipWarnKey = key;
     logger.warn(event, fields);
 }
+/**
+ * Which prompt a stopped answer is about (Issue #3706): the type, the question,
+ * the option labels and `approvalTarget` — what {@link promptFrameKey} tells
+ * apart — but NOT where the cursor is. The keys that were sent may have moved
+ * the cursor themselves (a `Down` whose Enter was withheld), and that must not
+ * make the same list read as a new one; a different list or a different command
+ * under the same question is a new prompt and is answered.
+ */
+function partialAnswerScreenKey(promptData) {
+    const options = promptData.type === 'multiple_choice'
+        ? promptData.options.map((o) => `${o.number}.${o.label}`).join('\n')
+        : promptData.options.join('\n');
+    return [(0, prompt_key_1.generatePromptKey)(promptData), options, withoutCursorMarks(promptData.approvalTarget ?? '')].join('\u0000');
+}
+/**
+ * `approvalTarget` with the cursor taken out: the generic parser copies the
+ * option panel into it, `❯` row included, so a moved cursor would otherwise
+ * read as another prompt. Leading indentation goes too — the cursor row is the
+ * one indented differently.
+ */
+function withoutCursorMarks(text) {
+    return text
+        .split('\n')
+        .map((line) => line.replace(/^[\s\u276F\u203A>\u25B6\u25BA\u25CF\u25CB\u25C9\u2192]+/u, ''))
+        .join('\n');
+}
+/** compositeKey -> the answer stopped part-way. globalThis for hot reload (#153). */
+const partialAnswers = (0, global_state_1.getOrInitGlobal)('__autoYesPartialAnswers', () => new Map());
+/**
+ * The answer stopped part-way that still applies: same session epoch, and the
+ * caller checks the prompt. Null when none, or when it was about another session.
+ */
+function getPartialAnswer(compositeKey, epoch) {
+    const partial = partialAnswers.get(compositeKey);
+    if (!partial)
+        return null;
+    if (partial.epoch !== epoch) {
+        partialAnswers.delete(compositeKey);
+        return null;
+    }
+    return partial;
+}
+/**
+ * Forget it: the prompt left the screen, another prompt came up, or the session ended.
+ *
+ * The sends still in flight that record under this key — moved here or not —
+ * are expired too (Issue #3713, re-instruction 2): they were registered before
+ * the screen they were typing at was seen gone, so their stop, coming back
+ * later, must not bring the memory back and leave the next confirmation of the
+ * same command unanswered. A send registered after this call is a new attempt
+ * and records as before. Expiring is the mark: it drops the attempt from the
+ * registry, so no per-key "forgotten up to seq" state has to outlive it.
+ *
+ * @param screenKey - Given when the memory is dropped because ANOTHER prompt is
+ *   on screen (re-instruction 3): only the sends at the forgotten memory's
+ *   screen are expired. A send at the screen now shown (Y, carried here by a
+ *   move while still in flight) stays — it keeps the successor off Y, and its
+ *   stop is still remembered when it comes back. Omitted (the prompt left the
+ *   screen), every send under the key is expired.
+ */
+function forgetPartialAnswer(compositeKey, screenKey) {
+    partialAnswers.delete(compositeKey);
+    for (const attempt of [...sendAttempts]) {
+        if (attempt.recordKey !== compositeKey)
+            continue;
+        if (screenKey !== undefined && attempt.screenKey !== screenKey)
+            continue;
+        expireSendAttempt(attempt);
+    }
+}
+/**
+ * {@link forgetPartialAnswer} for every instance of a worktree, and the sends
+ * still in flight there are expired (Issue #3713): a slow tick that comes back
+ * after the worktree's sessions went away records nothing. For the worktree
+ * being deleted only; disabling every agent keeps both (`stopAutoYesPollingByWorktree`'s
+ * `keepPartialAnswers`).
+ */
+function forgetPartialAnswersByWorktree(worktreeId) {
+    for (const key of (0, auto_yes_state_1.filterCompositeKeysByWorktree)([...partialAnswers.keys()], worktreeId)) {
+        partialAnswers.delete(key);
+    }
+    const inWorktree = new Set((0, auto_yes_state_1.filterCompositeKeysByWorktree)([...sendAttempts].map((attempt) => attempt.recordKey), worktreeId));
+    for (const attempt of [...sendAttempts]) {
+        if (inWorktree.has(attempt.recordKey))
+            expireSendAttempt(attempt);
+    }
+}
+/** Forget every one, and expire every send in flight: server shutdown, and a test seam. */
+function clearPartialAnswers() {
+    partialAnswers.clear();
+    for (const attempt of [...sendAttempts])
+        expireSendAttempt(attempt);
+}
+/** The sends in flight. globalThis for hot reload (#153), like the Map above. */
+const sendAttempts = (0, global_state_1.getOrInitGlobal)('__autoYesSendAttempts', () => new Set());
+const sendAttemptSeq = (0, global_state_1.getOrInitGlobal)('__autoYesSendAttemptSeq', () => ({ last: 0 }));
+/** Register a send about to start (the poller, before `sendPromptAnswer`). */
+function beginSendAttempt(compositeKey, screenKey, epoch) {
+    const attempt = {
+        seq: ++sendAttemptSeq.last,
+        screenKey,
+        recordKey: compositeKey,
+        recordEpoch: epoch,
+        moved: false,
+        state: 'pending',
+    };
+    sendAttempts.add(attempt);
+    return attempt;
+}
+/**
+ * The send came back. `keysSent` — it was stopped with keys already on the
+ * pane — records the partial answer under the attempt's key as it is now, when
+ * that key's session is still the one the keys went to; otherwise (sent in
+ * full, stopped before any key, or failed) only the attempt itself is removed.
+ * A second call, or a call on an expired attempt, does nothing.
+ */
+function settleSendAttempt(attempt, keysSent, at = Date.now()) {
+    if (attempt.state !== 'pending')
+        return;
+    attempt.state = 'settled';
+    sendAttempts.delete(attempt);
+    if (!keysSent)
+        return;
+    // A relaunch since (`beginAgentSession`): the process the keys went to is gone.
+    if ((0, auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch)(attempt.recordKey) !== attempt.recordEpoch)
+        return;
+    // A send registered later (the successor's, after a move) already recorded
+    // the same session's newer screen: that is what is in the input now.
+    const recorded = partialAnswers.get(attempt.recordKey);
+    if (recorded !== undefined && recorded.epoch === attempt.recordEpoch && recorded.seq > attempt.seq)
+        return;
+    partialAnswers.set(attempt.recordKey, {
+        screenKey: attempt.screenKey,
+        epoch: attempt.recordEpoch,
+        at,
+        seq: attempt.seq,
+    });
+}
+function expireSendAttempt(attempt) {
+    if (attempt.state === 'pending')
+        attempt.state = 'expired';
+    sendAttempts.delete(attempt);
+}
+/**
+ * Is a send that a worktree ID move carried to `compositeKey` still in flight
+ * at this screen of this session (Issue #3713)? Its keys may already be on the
+ * pane, so the poller under the new key does not type at the same prompt until
+ * it comes back. Sends that were not moved are not counted: the paths without a
+ * move stay as they were.
+ */
+function hasMovedSendInFlight(compositeKey, epoch, screenKey) {
+    for (const attempt of sendAttempts) {
+        if (attempt.moved &&
+            attempt.recordKey === compositeKey &&
+            attempt.recordEpoch === epoch &&
+            attempt.screenKey === screenKey) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Carry the partial answers and the sends in flight of the sessions a worktree
+ * ID move renamed to their new keys (Issue #3713). Synchronous: the caller runs
+ * it right after the renames, before any poller restarts.
+ *
+ * Only what belongs to the session that moved goes: the source's epoch must
+ * still be `sourceEpoch`, and so must the record's. Every source is read before
+ * any destination is written, so a swap (A↔B) or a chain (A→B, B→C) moves each
+ * record once, with its own session. At a destination, what was recorded for
+ * the session that used to have that name is dropped — its process is not the
+ * one now there. The epochs themselves (and the Enter fallback's record) are not
+ * moved: a record takes the destination key's current epoch.
+ *
+ * @param moves - Only the renames that succeeded in both stages
+ * @returns The new keys that received a partial answer or a send in flight
+ */
+function movePartialAnswers(moves) {
+    const carried = moves
+        .filter((move) => move.oldKey !== move.newKey)
+        .map((move) => {
+        const current = (0, auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch)(move.oldKey) === move.sourceEpoch;
+        const partial = partialAnswers.get(move.oldKey);
+        return {
+            move,
+            partial: current && partial !== undefined && partial.epoch === move.sourceEpoch ? partial : null,
+            attempts: current
+                ? [...sendAttempts].filter((attempt) => attempt.recordKey === move.oldKey && attempt.recordEpoch === move.sourceEpoch)
+                : [],
+        };
+    });
+    const carriedAttempts = new Set(carried.flatMap((entry) => entry.attempts));
+    // Detach every source first — only what is carried: a record the epochs
+    // left out (a session begun under the old key while the renames ran) stays.
+    for (const { move, partial } of carried) {
+        if (partial !== null && partialAnswers.get(move.oldKey) === partial)
+            partialAnswers.delete(move.oldKey);
+    }
+    // The destinations' previous sessions' records.
+    for (const { move } of carried) {
+        partialAnswers.delete(move.newKey);
+        for (const attempt of [...sendAttempts]) {
+            if (attempt.recordKey === move.newKey && !carriedAttempts.has(attempt))
+                expireSendAttempt(attempt);
+        }
+    }
+    // Then arrive.
+    const received = [];
+    for (const { move, partial, attempts } of carried) {
+        const epoch = (0, auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch)(move.newKey);
+        if (partial !== null)
+            partialAnswers.set(move.newKey, { ...partial, epoch });
+        for (const attempt of attempts) {
+            attempt.recordKey = move.newKey;
+            attempt.recordEpoch = epoch;
+            attempt.moved = true;
+        }
+        if (partial !== null || attempts.length > 0)
+            received.push(move.newKey);
+    }
+    return received;
+}

package/dist/server/src/lib/polling/auto-yes-suppression-reason.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARTIAL_ANSWER_SUPPRESSION_REASON = void 0;
+/** Issue #3706: the reason the poller records for an answer stopped part-way. */
+exports.PARTIAL_ANSWER_SUPPRESSION_REASON = 'partial-answer';