commandmate 0.44.3 → 0.45.1

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

@@ -34,6 +34,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeAgentEventSource = void 0;
 exports.encodeClaudeVerdict = encodeClaudeVerdict;
+exports.extractClaudeEventDetail = extractClaudeEventDetail;
 const uat_isolation_1 = require("../../../../config/uat-isolation");
 const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const ask_user_question_payload_1 = require("../../../../lib/hooks/ask-user-question-payload");
@@ -44,6 +45,7 @@ const event_mapper_1 = require("../event-mapper");
 const hook_event_vocabulary_1 = require("../hook-event-vocabulary");
 const model_switch_1 = require("./model-switch");
 const queued_notice_1 = require("./queued-notice");
+const self_resume_1 = require("./self-resume");
 const tool_id_1 = require("./tool-id");
 /**
  * The no-decision body, byte for byte what the #1721 spike returned for D5.
@@ -85,6 +87,20 @@ function encodeClaudeVerdict(verdict) {
         },
     };
 }
+/**
+ * The subtype of one Claude event.
+ *
+ * Every event but `stop` is the shared snake_case reading (S2). A `stop` is
+ * {@link SELF_RESUME_PENDING_DETAIL} when the session's transcript shows
+ * background work that has not been notified yet (Issue #3430), and has no
+ * subtype otherwise — which is what every Claude `stop` had before.
+ */
+function extractClaudeEventDetail(event, payload) {
+    if (event === 'stop' && (0, self_resume_1.claudeStopLeavesBackgroundWork)(payload)) {
+        return agent_event_types_1.SELF_RESUME_PENDING_DETAIL;
+    }
+    return (0, hook_event_vocabulary_1.extractSnakeCaseEventDetail)(event, payload);
+}
 /**
  * Claude Code as an event source.
  *
@@ -127,11 +143,12 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
         // JSONL when the poller asks (#2121); the gate dispatches on this word
         // rather than on the tool id.
         transcriptHistory: 'pull',
-        // Issue #2614. Claude Code does resume itself (background tasks, session
-        // crons), and its `Stop` payload carries `background_tasks` /
-        // `session_crons` — but only the empty form has been captured, so nothing
-        // reads them yet and this stays false until a non-empty one is measured.
-        stopReportsSelfResume: false,
+        // Issue #3430 (#2614 for Claude). A `Stop` whose transcript shows a
+        // background `Bash` / `Monitor` / subagent not yet notified carries
+        // `SELF_RESUME_PENDING_DETAIL`: the notification opens the next turn by
+        // itself. The payload's `background_tasks` is still unread — only its empty
+        // form has been captured. See `./self-resume` and `extractDetail` below.
+        stopReportsSelfResume: true,
     },
     // S1. A plain name table is enough *for this tool* — one native name, one
     // word, no predicates — so it is expressed as rules built from the table
@@ -163,8 +180,8 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
     // Issue #3330. A background-task notice attached to the running turn fires
     // `UserPromptSubmit` too, and continues that turn rather than opening one.
     promptJoinsOpenTurn: queued_notice_1.isClaudeQueuedNoticePrompt,
-    // S2.
-    extractDetail: hook_event_vocabulary_1.extractSnakeCaseEventDetail,
+    // S2, plus the `Stop` that leaves background work behind (Issue #3430).
+    extractDetail: extractClaudeEventDetail,
     // S7. Both parsers are strict and answer null for anything they cannot vouch
     // for; the callers turn null into "no structured data", which degrades to the
     // behaviour of a machine without hooks rather than into a guess.

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

@@ -30,7 +30,7 @@ const global_state_1 = require("../global-state");
  * What tells two prompts apart for the published record: the type, the
  * question and the option labels.
  *
- * Not the poller's `promptFrameKey`: that one also carries the cursor and
+ * Not the poller's `promptFrameKey` (in `auto-yes-poller-state.ts`): that one also carries the cursor and
  * `approvalTarget`, and the status API reads a different number of rows than
  * the poller does, so `approvalTarget` can differ between the two readings of
  * one screen. The record is matched against the status API's prompt (to say

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

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Auto-Yes poller state and its once-per-frame WARN (Issue #3411).
+ *
+ * Moved out of auto-yes-poller.ts unchanged; the poller re-exports
+ * `AutoYesPollerState`. Must not import auto-yes-poller.ts (cycle).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptFrameKey = promptFrameKey;
+exports.warnOncePerFrame = warnOncePerFrame;
+const prompt_key_1 = require("../detection/prompt-key");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('auto-yes-poller');
+/**
+ * Issue #2995: what makes two ticks "the same prompt" for `warnOncePerFrame`.
+ *
+ * `generatePromptKey` alone is type + question, and the question the detector
+ * extracts from an agent's reply is often a fixed line above the list, so two
+ * different lists would share it. The option rows (and where the cursor sits)
+ * plus `approvalTarget` -- the current prompt's own panel, which leaves out
+ * scrollback and footers that change while the prompt does not -- separate them.
+ * Not the whole pane: a status bar that ticks every second would defeat it.
+ */
+function promptFrameKey(promptData) {
+    const options = promptData.type === 'multiple_choice'
+        ? promptData.options.map((o) => `${o.isDefault ? '>' : ''}${o.number}.${o.label}`).join('\n')
+        : '';
+    return [(0, prompt_key_1.generatePromptKey)(promptData), options, promptData.approvalTarget ?? ''].join('\u0000');
+}
+/**
+ * Issue #2995: print a "did not answer" line as WARN once per frame.
+ *
+ * The poller re-reads a static pane every 2s, so a frame Auto-Yes leaves alone
+ * (a reply quoting `1. Yes / 2. No`, a launch dialog, a policy-withheld prompt,
+ * a foreign session) would otherwise print the same WARN on every tick. The
+ * first one stays WARN -- it is what tells a silently stalled worker apart --
+ * and repeats for the same frame drop to `debug`. The frame is identified by
+ * the event, `promptFrameKey()` and the event's own detail; a different
+ * prompt, a different reason, or a tick with no prompt / an answer sent (both
+ * clear the key) makes the next line WARN again.
+ * `recordPolicySuppression()` is not throttled: `capture --json` and `wait`
+ * read the latest record, not the log.
+ */
+function warnOncePerFrame(pollerState, frameKey, event, fields) {
+    const key = `${event}\u0000${frameKey}`;
+    if (pollerState.lastSkipWarnKey === key) {
+        logger.debug(event, { ...fields, repeated: true });
+        return;
+    }
+    pollerState.lastSkipWarnKey = key;
+    logger.warn(event, fields);
+}

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

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * The suppression exits of `detectAndRespondToPrompt` (Issue #3214), moved out
+ * of auto-yes-poller.ts unchanged (Issue #3411). Must not import
+ * auto-yes-poller.ts (cycle) or `../tmux/tmux` (tmux import allowlist).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suppressAndWarnOnce = suppressAndWarnOnce;
+exports.suppressIfNotOursToAnswer = suppressIfNotOursToAnswer;
+exports.suppressUnclassifiedFrame = suppressUnclassifiedFrame;
+const detect_1 = require("../detection/tools/codex/detect");
+const cli_patterns_1 = require("../detection/cli-patterns");
+const auto_yes_suppression_state_1 = require("./auto-yes-suppression-state");
+const auto_yes_dialog_gate_1 = require("./auto-yes-dialog-gate");
+const auto_yes_poller_state_1 = require("./auto-yes-poller-state");
+/**
+ * Issue #3214: the form the four suppression exits of `detectAndRespondToPrompt`
+ * share. Records why Auto-Yes left the prompt alone (`recordPolicySuppression`,
+ * not throttled), then prints the WARN once per frame (`warnOncePerFrame`).
+ *
+ * @param suppression - Handed to `recordPolicySuppression` as is
+ * @param warnFrameKey - Handed to `warnOncePerFrame` as is: the prompt's
+ *   `frameKey` plus the exit's own detail
+ * @param event - The WARN's log name
+ * @param detail - The WARN's fields after `worktreeId`, `cliToolId` and `instanceId`
+ */
+function suppressAndWarnOnce(prompt, suppression, warnFrameKey, event, detail) {
+    const { worktreeId, cliToolId, instanceId } = prompt;
+    (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, suppression);
+    (0, auto_yes_poller_state_1.warnOncePerFrame)(prompt.pollerState, warnFrameKey, event, {
+        worktreeId,
+        cliToolId,
+        instanceId,
+        ...detail,
+    });
+}
+/**
+ * Issue #3214: steps 3, 3.2 and 3.5 of `detectAndRespondToPrompt` -- the frames
+ * that read as a prompt and are still not Auto-Yes's to answer, judged in the
+ * order they always were. "The detection above" in the comments below is that
+ * function's step 1.
+ *
+ * Issue #3397: step 3.5 no longer records its refusal here. It hands the gate's
+ * verdict back so `tryEnterFallback` can look at the frame first, and records
+ * through {@link suppressUnclassifiedFrame} when that sends nothing. Steps 3 and
+ * 3.2 still win: an Enter never reaches codex's launch dialogs or its `/model`
+ * picker.
+ *
+ * @param frame - The tick's one normalised frame (Issue #3183)
+ */
+function suppressIfNotOursToAnswer(prompt, frame) {
+    const { cliToolId, promptData, frameKey } = prompt;
+    // 3. Issue #1829: codex's own launch dialogs are CodexTool.waitForReady()'s
+    // to answer, not the poller's. Every one of them defaults to option 1, and
+    // the base rules answer the default:
+    //
+    //   "Hooks need review"  -> 1. Review hooks   (undoes Issue #1760; the pane
+    //                           then sits two screens deep in a review UI that
+    //                           only `t`/`esc` leave, reported as `running`)
+    //   "Update available"   -> 1. Update now     (undoes Issue #890; runs
+    //                           `npm install -g @openai/codex`, killing codex)
+    //   "Do you trust …"     -> 1. Yes, continue
+    //
+    // waitForReady answers the same screens deliberately and differently ('3',
+    // '2', '1' — each without a trailing Enter), but only during startSession,
+    // while this poller runs on its own 2s phase for the life of the session.
+    // Whichever sees the dialog first decides, so the fix is to leave them all
+    // to the tool. Auto-answer layer only: the detection above still reports the
+    // prompt, so the human keeps seeing the screen and the response poller
+    // still notifies them about it.
+    const launchDialog = cliToolId === 'codex' ? (0, cli_patterns_1.getCodexLifecycleDialog)(frame) : null;
+    if (launchDialog) {
+        // Recorded through the #1684 channel so `capture --json` and `cmate wait`
+        // can name the reason instead of showing a worker that went quiet.
+        suppressAndWarnOnce(prompt, { reason: 'agent-launch-dialog', mode: null, promptType: promptData.type }, `${frameKey}\u0000${launchDialog}`, 'poller:auto-yes-skipped-launch-dialog', { dialog: launchDialog, promptType: promptData.type });
+        return { kind: 'left-alone' };
+    }
+    // 3.2. Issue #3062: codex's `/model` picker (both stages) is not ours to
+    // answer. A digit there is an immediate decision, so the base rules'
+    // default would choose the model and effort for the operator. Judged by the
+    // picker's own footer, not by `kind: picker`, which the hooks screens share.
+    // The tool's `detectPrompt` still reports the prompt, so `/prompt-response`
+    // (the human's answer) is unaffected. Reuses `unclassified-frame`: the tool
+    // recognised the frame and deliberately declined it.
+    if (cliToolId === 'codex' && (0, detect_1.isCodexModelPickerFrame)(frame)) {
+        suppressAndWarnOnce(prompt, { reason: 'unclassified-frame', mode: null, promptType: promptData.type }, `${frameKey}\u0000codex-model-picker`, 'poller:auto-yes-skipped-model-picker', { promptType: promptData.type });
+        return { kind: 'left-alone' };
+    }
+    // 3.5. Issue #1928 (§4 D1 decision 4): the generic numbered-list inference is
+    // not enough to send an answer. The detection above judges the ROWS, and the
+    // rows of an agent's own reply can be indistinguishable from a dialog's --
+    // opencode 1.18 answering "list three options and ask which one" is the
+    // reported case (#1896), and the `1` this poller sent in reply was not
+    // answering anything, it was SENT AS A USER UTTERANCE. What separates the two
+    // is position and chrome, which only the tool's own module knows, so the
+    // decision is delegated to `detectDialog` (the seam #1927 declared).
+    //
+    // Per tool, and only for tools whose dialogs were measured from their own
+    // live captures -- see AUTO_YES_DIALOG_GATE_DEFAULT_MODE. An ungated tool
+    // reaches `allowed: true` without being judged, which is the pre-#1928
+    // behaviour and the right one where nobody has measured anything.
+    //
+    // Recorded through the #1684 channel with the reason code #1924 landed for
+    // exactly this position, so `capture --json` and `cmate wait` can name the
+    // gap instead of showing a worker that silently went quiet.
+    const dialogGate = (0, auto_yes_dialog_gate_1.evaluateAutoYesDialogGate)(cliToolId, promptData.type, frame);
+    if (!dialogGate.allowed) {
+        return { kind: 'dialog-gate-refused', dialogGate };
+    }
+    return { kind: 'ours' };
+}
+/**
+ * Step 3.5's record: the tool's dialog detector did not vouch for the frame and
+ * nothing was sent (Issue #1928). Split out of `suppressIfNotOursToAnswer` by
+ * Issue #3397, unchanged, so it runs after `tryEnterFallback` declined.
+ */
+function suppressUnclassifiedFrame(prompt, dialogGate) {
+    const { promptData, frameKey } = prompt;
+    suppressAndWarnOnce(prompt, { reason: 'unclassified-frame', mode: null, promptType: promptData.type }, `${frameKey}\u0000${dialogGate.dialog?.kind ?? ''}\u0000${dialogGate.mode}`, 'poller:auto-yes-skipped-unclassified-frame', {
+        promptType: promptData.type,
+        dialogKind: dialogGate.dialog?.kind ?? null,
+        answerMode: dialogGate.dialog?.answerMode ?? null,
+        gateMode: dialogGate.mode,
+    });
+}

package/dist/server/src/lib/polling/prompt-dedup.js

@@ -6,15 +6,53 @@
  * Uses SHA-256 content hash with an in-memory cache (Map<pollerKey, hash>).
  * Design decision [DR1-006]: In-memory only (no DB layer).
  * Process restart may cause a single duplicate, which is acceptable (KISS).
+ *
+ * ## How often the skip says so (Issue #3538)
+ *
+ * A full-screen TUI (copilot, opencode) keeps polling while it sits on a
+ * prompt, so the same prompt is a duplicate on every 2 s tick until it is
+ * answered, and `duplicate-prompt-skipped` used to be logged on each of them.
+ * The run of duplicate ticks is counted here, the same way `response-dedup`
+ * counts `duplicate-response-skipped` (#3519): the line is written on the first
+ * tick of a run and then once per {@link DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL}
+ * ticks. The count is about one particular cached hash, so it never outlives
+ * it — the functions below that drop or move the hash drop or move the count
+ * too. The one exception runs the other way: a tick that reads a frame with no
+ * live prompt on it ends the run without touching the hash
+ * ({@link resetDuplicatePromptSkipStreak}), because the prompt left the screen
+ * while the guard still has to keep it from being saved twice. A returning
+ * prompt is then still suppressed, but its first duplicate logs as the first
+ * of a new run.
+ *
+ * Only the log line is thinned. `recordPromptDedupSkip` (#1695) is still called
+ * on every duplicate tick; its tally is what `capture --json` reports.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL = void 0;
 exports.isDuplicatePrompt = isDuplicatePrompt;
+exports.claimDuplicatePromptSkipLog = claimDuplicatePromptSkipLog;
+exports.resetDuplicatePromptSkipStreak = resetDuplicatePromptSkipStreak;
 exports.clearPromptHashCache = clearPromptHashCache;
 exports.renamePromptHashCacheKey = renamePromptHashCacheKey;
 exports.normalizePromptForDedup = normalizePromptForDedup;
 const crypto_1 = require("crypto");
 const global_state_1 = require("../global-state");
+const response_dedup_1 = require("./response-dedup");
 const promptHashCache = (0, global_state_1.getOrInitGlobal)('__promptHashCache', () => new Map());
+/**
+ * In-memory cache: pollerKey -> how many duplicate ticks in a row the current
+ * cached prompt hash has been skipped (Issue #3538). Absence means none yet.
+ *
+ * On `globalThis` for the same reason `promptHashCache` is, and cleared and
+ * moved at exactly the same moments — see the module comment.
+ */
+const duplicatePromptSkipStreak = (0, global_state_1.getOrInitGlobal)('__duplicatePromptSkipStreak', () => new Map());
+/**
+ * How many duplicate ticks separate two `duplicate-prompt-skipped` lines
+ * (Issue #3538). Shared with `duplicate-response-skipped` (#3519): one line a
+ * minute at the poller's 2 s tick.
+ */
+exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL = response_dedup_1.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL;
 /**
  * Check if the given prompt content is a duplicate of the last saved prompt
  * for the same pollerKey. If not a duplicate, updates the cache.
@@ -29,8 +67,46 @@ function isDuplicatePrompt(pollerKey, content) {
         return true;
     }
     promptHashCache.set(pollerKey, hash);
+    // Issue #3538: a new prompt starts a new run of duplicate ticks.
+    duplicatePromptSkipStreak.delete(pollerKey);
     return false;
 }
+/**
+ * Count one duplicate prompt tick for this pollerKey and say whether it should
+ * be logged (Issue #3538).
+ *
+ * A claim: it advances the count, so call it exactly once per duplicate tick.
+ * Logs on the first tick of a run and then on every
+ * {@link DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL}th tick after it (ticks 1,
+ * 1+N, 1+2N, …).
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ * @returns Whether to log, the run length so far, and the ticks left unlogged
+ *   since the previous line
+ */
+function claimDuplicatePromptSkipLog(pollerKey) {
+    const consecutive = (duplicatePromptSkipStreak.get(pollerKey) ?? 0) + 1;
+    duplicatePromptSkipStreak.set(pollerKey, consecutive);
+    const log = (consecutive - 1) % exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL === 0;
+    const suppressed = consecutive === 1 ? 0 : exports.DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL - 1;
+    return { log, consecutive, suppressed };
+}
+/**
+ * End the current run of duplicate prompt ticks for this pollerKey without
+ * touching the cached hash (Issue #3538).
+ *
+ * Called by `response-checker` on every tick that does not reach the prompt
+ * guard with a live prompt — a working screen, an unfinished frame, a reply.
+ * The prompt is no longer on screen, so if the same prompt comes back the next
+ * duplicate is the first of a new run and logs. The hash stays: whether the
+ * returning prompt is saved again is the guard's question (#565), and this
+ * Issue only thins the log line.
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ */
+function resetDuplicatePromptSkipStreak(pollerKey) {
+    duplicatePromptSkipStreak.delete(pollerKey);
+}
 /**
  * Clear the prompt hash cache for a specific pollerKey.
  * Called during session cleanup / stopPolling.
@@ -39,6 +115,8 @@ function isDuplicatePrompt(pollerKey, content) {
  */
 function clearPromptHashCache(pollerKey) {
     promptHashCache.delete(pollerKey);
+    // Issue #3538: the skip count is about the same hash.
+    duplicatePromptSkipStreak.delete(pollerKey);
 }
 /**
  * Move the cached hash from one pollerKey to another.
@@ -57,9 +135,22 @@ function renamePromptHashCacheKey(oldKey, newKey) {
     if (oldKey === newKey)
         return;
     const hash = promptHashCache.get(oldKey);
+    const streak = duplicatePromptSkipStreak.get(oldKey);
     promptHashCache.delete(oldKey);
-    if (hash !== undefined)
-        promptHashCache.set(newKey, hash);
+    duplicatePromptSkipStreak.delete(oldKey);
+    if (hash === undefined)
+        return;
+    promptHashCache.set(newKey, hash);
+    // Issue #3538: the skip count moves with the hash, so a rename mid-run does
+    // not restart the thinning and log as if a new run had begun. Whenever the
+    // hash under `newKey` is replaced, so is its count — a count left over from
+    // the hash that was there before is about a different prompt.
+    if (streak !== undefined) {
+        duplicatePromptSkipStreak.set(newKey, streak);
+    }
+    else {
+        duplicatePromptSkipStreak.delete(newKey);
+    }
 }
 /**
  * Normalize prompt content before deduplication check.

package/dist/server/src/lib/polling/response-checker.js

@@ -491,6 +491,15 @@ function extractCompletedTurn(ctx, output, lastCapturedLine) {
     // Extract response
     const result = extractResponse(output, lastCapturedLine, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES);
     if (!result || !result.isComplete) {
+        // Issue #3538: an unfinished frame was read and carries no live prompt (the
+        // early prompt check in `extractResponse` would have returned it complete),
+        // so a run of duplicate prompt ticks is over; the hash is kept — see the
+        // helper. Only when the frame WAS read: a null result is extraction being
+        // skipped on the line count ("no new output"), which says nothing about
+        // whether the prompt is still on screen, and neither do the cursor returns
+        // further down.
+        if (result)
+            (0, prompt_dedup_1.resetDuplicatePromptSkipStreak)(pollerKey);
         // DR-004 windowing: Only check tail lines
         const { thinkingPattern } = (0, cli_patterns_1.getCliToolPatterns)(cliToolId);
         const cleanOutput = (0, cli_patterns_1.stripAnsi)(output);
@@ -565,7 +574,19 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
         // classified (#1676) look identical from the CLI — both say "nothing was
         // recorded". Count the skip so the payload can tell them apart.
         (0, prompt_dedup_state_1.recordPromptDedupSkip)(worktreeId, cliToolId, instanceId);
-        logger.info('duplicate-prompt-skipped', { worktreeId, cliToolId });
+        // Issue #3538: the tally above is counted on every tick; the log line is
+        // not. A full-screen TUI sits on its prompt for as long as it stays
+        // unanswered, a duplicate every 2 s. The first tick of a run logs exactly
+        // as before; after that one line per `DUPLICATE_PROMPT_SKIP_LOG_TICK_INTERVAL`
+        // ticks, with the run length and how many ticks went unlogged (#3519).
+        const skipLog = (0, prompt_dedup_1.claimDuplicatePromptSkipLog)(pollerKey);
+        if (skipLog.log) {
+            logger.info('duplicate-prompt-skipped', {
+                worktreeId,
+                cliToolId,
+                ...(skipLog.consecutive > 1 ? { consecutive: skipLog.consecutive, suppressed: skipLog.suppressed } : {}),
+            });
+        }
         return false;
     }
     // Issue #571: Clean TUI decorations from Copilot prompt content before saving
@@ -723,7 +744,21 @@ async function recheckDuplicateResponse(ctx, result, claudeMetadata) {
     // logged nothing at all, so a reply that never reached History left no
     // trace anywhere. Same action name shape as its sibling so both skips
     // are found by one grep.
-    logger.info('duplicate-response-skipped', { worktreeId, cliToolId, instanceId: resolvedInstanceId });
+    //
+    // Issue #3519: but not on every tick. A finished screen that stays up is a
+    // duplicate on each of the cycle's 900 ticks, and logging all of them was
+    // 51,933 lines a day. The first tick of a run logs exactly as before; after
+    // that one line per `DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL` ticks, with
+    // the run length and how many ticks went unlogged since the last line.
+    const skipLog = (0, response_dedup_1.claimDuplicateResponseSkipLog)(pollerKey);
+    if (skipLog.log) {
+        logger.info('duplicate-response-skipped', {
+            worktreeId,
+            cliToolId,
+            instanceId: resolvedInstanceId,
+            ...(skipLog.consecutive > 1 ? { consecutive: skipLog.consecutive, suppressed: skipLog.suppressed } : {}),
+        });
+    }
     (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
     // Issue #2399: the skip above is about the SCREEN, and until this Issue
     // it also ended the tick for the TRANSCRIPT READER 100 lines below —
@@ -1156,6 +1191,9 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         if (promptIsLive) {
             return savePromptMessage(ctx, promptDetection, result, isFullScreenTui);
         }
+        // Issue #3538: a finished frame without a live prompt ends the run of
+        // duplicate prompt ticks, as an unfinished one does in `extractCompletedTurn`.
+        (0, prompt_dedup_1.resetDuplicatePromptSkipStreak)(pollerKey);
         // Validate response content is not empty
         if (!result.response || result.response.trim() === '') {
             (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);

package/dist/server/src/lib/polling/response-dedup.js

@@ -39,10 +39,22 @@
  * hash, and the worktree rename all have to treat the two the same, and the
  * only way to guarantee that without touching `response-poller-core` (which
  * owns those three calls) is for one function to clear both.
+ *
+ * ## The third cache: how often the skip says so (#3519)
+ *
+ * The skip logs `duplicate-response-skipped` so a reply missing from History
+ * leaves a grep-able trace (#1695). Logged on every tick, a screen that stays
+ * up writes that line every 2 s for the whole cycle — 51,933 lines in 24 h,
+ * 80% of the server log. The run of duplicate ticks is counted here so the line
+ * is written on the first tick of a run and then once per
+ * {@link DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL} ticks. The count is about
+ * one particular cached hash, so it lives and dies with it for the same reason
+ * the recheck does.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = void 0;
+exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL = exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = void 0;
 exports.isDuplicateResponse = isDuplicateResponse;
+exports.claimDuplicateResponseSkipLog = claimDuplicateResponseSkipLog;
 exports.markStructuredHistoryRecheckPending = markStructuredHistoryRecheckPending;
 exports.settleStructuredHistoryRecheck = settleStructuredHistoryRecheck;
 exports.claimStructuredHistoryRecheck = claimStructuredHistoryRecheck;
@@ -79,6 +91,25 @@ const structuredHistoryRecheckCache = (0, global_state_1.getOrInitGlobal)('__str
  * or the cycle ends, the entry is gone.
  */
 exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = 3;
+/**
+ * In-memory cache: pollerKey -> how many duplicate ticks in a row the current
+ * cached hash has been skipped (Issue #3519). Absence means none yet.
+ *
+ * On `globalThis` for the same reason `responseHashCache` is, and cleared and
+ * moved at exactly the same moments — see the module comment. A new
+ * (non-duplicate) response restarts it in {@link isDuplicateResponse}.
+ */
+const duplicateResponseSkipStreak = (0, global_state_1.getOrInitGlobal)('__duplicateResponseSkipStreak', () => new Map());
+/**
+ * How many duplicate ticks separate two `duplicate-response-skipped` lines
+ * (Issue #3519).
+ *
+ * At the poller's 2 s tick this is one line a minute while a finished screen
+ * stays up, so a 900-tick cycle writes 30 lines instead of 899. The first tick
+ * of a run always logs, so the #1695 trace — "this reply was skipped, at this
+ * time" — is still there for every run; what is dropped is the repetition.
+ */
+exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL = 30;
 /**
  * Check whether the given response content was already saved during the current
  * polling cycle for the same pollerKey. If it is new, updates the cache.
@@ -93,8 +124,30 @@ function isDuplicateResponse(pollerKey, content) {
         return true;
     }
     responseHashCache.set(pollerKey, hash);
+    // Issue #3519: a new response starts a new run of duplicate ticks.
+    duplicateResponseSkipStreak.delete(pollerKey);
     return false;
 }
+/**
+ * Count one duplicate tick for this pollerKey and say whether it should be
+ * logged (Issue #3519).
+ *
+ * A claim, like {@link claimStructuredHistoryRecheck}: it advances the count, so
+ * call it exactly once per duplicate tick. Logs on the first tick of a run and
+ * then on every {@link DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL}th tick after
+ * it (ticks 1, 1+N, 1+2N, …).
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @returns Whether to log, the run length so far, and the ticks left unlogged
+ *   since the previous line
+ */
+function claimDuplicateResponseSkipLog(pollerKey) {
+    const consecutive = (duplicateResponseSkipStreak.get(pollerKey) ?? 0) + 1;
+    duplicateResponseSkipStreak.set(pollerKey, consecutive);
+    const log = (consecutive - 1) % exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL === 0;
+    const suppressed = consecutive === 1 ? 0 : exports.DUPLICATE_RESPONSE_SKIP_LOG_TICK_INTERVAL - 1;
+    return { log, consecutive, suppressed };
+}
 /**
  * Note that the transcript reader has unfinished business for this pollerKey
  * (Issue #2399).
@@ -177,6 +230,8 @@ function claimStructuredHistoryRecheck(pollerKey) {
 function clearResponseHashCache(pollerKey) {
     responseHashCache.delete(pollerKey);
     structuredHistoryRecheckCache.delete(pollerKey);
+    // Issue #3519: the skip count is about the same hash.
+    duplicateResponseSkipStreak.delete(pollerKey);
 }
 /**
  * Move the cached hash from one pollerKey to another.
@@ -206,4 +261,10 @@ function renameResponseHashCacheKey(oldKey, newKey) {
     structuredHistoryRecheckCache.delete(oldKey);
     if (ticksToWait !== undefined)
         structuredHistoryRecheckCache.set(newKey, ticksToWait);
+    // Issue #3519: the skip count moves with the hash too, so a rename mid-run
+    // does not restart the thinning and log as if a new run had begun.
+    const streak = duplicateResponseSkipStreak.get(oldKey);
+    duplicateResponseSkipStreak.delete(oldKey);
+    if (streak !== undefined)
+        duplicateResponseSkipStreak.set(newKey, streak);
 }

package/dist/server/src/lib/session/agent-event-dedup.js

@@ -322,8 +322,8 @@ function shortSessionTag(sessionId) {
 /**
  * Forget every `stop` one session of one instance has claimed (Issue #3289).
  *
- * Every subtype: antigravity posts `stop` / `self_resume_pending` (#2614)
- * beside the plain one.
+ * Every subtype: antigravity (#2614) and claude (#3430) post `stop` /
+ * `self_resume_pending` beside the plain one.
  */
 function releaseStopClaims(composite, sessionId) {
     releaseClaims(composite, ['stop'], sessionId);

package/dist/server/src/lib/session/agent-event-state.js

@@ -39,7 +39,7 @@
  * @module lib/session/agent-event-state
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = exports.recordAskUserQuestion = exports.getAskUserQuestion = exports.clearAskUserQuestion = exports.isAwaitingInstruction = exports.getAwaitingInstruction = exports.STRUCTURED_STATE_MAX_AGE_MS = exports.getStructuredSessionState = exports.observeScraperCompletionEvidence = exports.joinOpenTurnFromDuplicate = exports.getPublishedAgentTurn = exports.getPendingDecisions = exports.getAgentTurn = exports.closeAgentTurn = exports.recordCapturedModelInfo = exports.recordAgentReportedModel = exports.recordAgentReportedEffort = exports.onAgentModelChange = exports.isSameAgentModelName = exports.getResolvedAgentModelInfo = exports.getLastReportedAgentEffort = exports.getLastKnownAgentModel = exports.getLastKnownAgentEffort = exports.getLastCapturedModelInfo = exports.getAgentModelBaseline = exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN = exports.shortSessionTag = exports.LIFECYCLE_AGENT_EVENT_TYPES = exports.isDuplicateAgentEvent = exports.getRecentEventKeyCount = exports.getRecentEventIdentityCount = exports.getAgentEventDropCounts = exports.classifyAgentEventDelivery = exports.agentEventKeyClaimedAt = exports.AGENT_EVENT_DEDUP_WINDOW_MS = void 0;
+exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = exports.recordAskUserQuestion = exports.getAskUserQuestion = exports.clearAskUserQuestion = exports.isAwaitingInstruction = exports.getAwaitingInstruction = exports.STRUCTURED_STATE_MAX_AGE_MS = exports.getStructuredSessionState = exports.observeScraperCompletionEvidence = exports.joinOpenTurnFromDuplicate = exports.isPreToolUseOutsideTurn = exports.getPublishedAgentTurn = exports.getPendingDecisions = exports.getAgentTurn = exports.closeAgentTurn = exports.recordCapturedModelInfo = exports.recordAgentReportedModel = exports.recordAgentReportedEffort = exports.onAgentModelChange = exports.isSameAgentModelName = exports.getResolvedAgentModelInfo = exports.getLastReportedAgentEffort = exports.getLastKnownAgentModel = exports.getLastKnownAgentEffort = exports.getLastCapturedModelInfo = exports.getAgentModelBaseline = exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN = exports.shortSessionTag = exports.LIFECYCLE_AGENT_EVENT_TYPES = exports.isDuplicateAgentEvent = exports.getRecentEventKeyCount = exports.getRecentEventIdentityCount = exports.getAgentEventDropCounts = exports.classifyAgentEventDelivery = exports.agentEventKeyClaimedAt = exports.AGENT_EVENT_DEDUP_WINDOW_MS = void 0;
 exports.recordAgentStopEvent = recordAgentStopEvent;
 exports.getLastStopEventAt = getLastStopEventAt;
 exports.recordAgentEvent = recordAgentEvent;
@@ -92,6 +92,7 @@ Object.defineProperty(exports, "closeAgentTurn", { enumerable: true, get: functi
 Object.defineProperty(exports, "getAgentTurn", { enumerable: true, get: function () { return agent_event_turn_2.getAgentTurn; } });
 Object.defineProperty(exports, "getPendingDecisions", { enumerable: true, get: function () { return agent_event_turn_2.getPendingDecisions; } });
 Object.defineProperty(exports, "getPublishedAgentTurn", { enumerable: true, get: function () { return agent_event_turn_2.getPublishedAgentTurn; } });
+Object.defineProperty(exports, "isPreToolUseOutsideTurn", { enumerable: true, get: function () { return agent_event_turn_2.isPreToolUseOutsideTurn; } });
 Object.defineProperty(exports, "joinOpenTurnFromDuplicate", { enumerable: true, get: function () { return agent_event_turn_2.joinOpenTurnFromDuplicate; } });
 Object.defineProperty(exports, "observeScraperCompletionEvidence", { enumerable: true, get: function () { return agent_event_turn_2.observeScraperCompletionEvidence; } });
 var agent_event_structured_state_2 = require("../../lib/session/agent-event-structured-state");