commandmate 0.47.2 → 0.49.0

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

@@ -10,6 +10,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reopenedTurns = exports.agentTurns = exports.generationStartedAt = void 0;
+exports.registerTurnOutcomeSink = registerTurnOutcomeSink;
+exports.toGenerationRef = toGenerationRef;
+exports.liveDecisionCount = liveDecisionCount;
 exports.currentGeneration = currentGeneration;
 exports.effectiveTurn = effectiveTurn;
 exports.livePendingDecisions = livePendingDecisions;
@@ -71,6 +74,38 @@ exports.reopenedTurns = (0, global_state_1.getOrInitGlobal)('__agentEventReopene
  * boundary rather than a cosmetic clash.
  */
 const turnSequence = (0, global_state_1.getOrInitGlobal)('__agentEventTurnSeq', () => ({ value: 0 }));
+/**
+ * Install the sink for outcomes this module produces outside a
+ * `recordAgentEvent` call. Registered by `waiting-episode-binding`, through
+ * `globalThis`, so this module imports nothing that imports it back.
+ */
+function registerTurnOutcomeSink(sink) {
+    globalThis.__agentEventTurnOutcomeSink = sink;
+}
+/** A generation as the waiting episode names it. */
+function toGenerationRef(generation) {
+    return generation === null ? { kind: 'none' } : { kind: 'opened', at: generation };
+}
+/** Live decisions held by a record, counted without retiring the expired ones. */
+function liveDecisionCount(turn, now) {
+    return turn.pendingDecisions.filter((decision) => (0, provisional_turn_1.isDecisionLive)(decision, now)).length;
+}
+/** Describe the instance's record before a transition rewrites it. */
+function describePrevious(turn, eventSessionId, at) {
+    if (turn === null)
+        return { kind: 'none' };
+    if (turn.closedAt !== null)
+        return { kind: 'closed', turnId: turn.turnId, closedBy: turn.closedBy ?? 'stop' };
+    if (turn.openedAt === null) {
+        const decisions = liveDecisionCount(turn, at);
+        return decisions > 0
+            ? { kind: 'dialog-only', turnId: turn.turnId, decisions, sessionId: turn.sessionId }
+            : { kind: 'display-only', turnId: turn.turnId };
+    }
+    return (0, provisional_turn_1.closesTurn)(turn, eventSessionId)
+        ? { kind: 'open-same-session', turnId: turn.turnId }
+        : { kind: 'open-other-session', turnId: turn.turnId };
+}
 // =============================================================================
 // Turn model (Issue #1930)
 // =============================================================================
@@ -283,10 +318,18 @@ function observeScraperCompletionEvidence(worktreeId, cliToolId, instanceId, com
  * were raised by a process that no longer exists, and answering one would
  * deliver a verdict into a slot nobody is holding.
  */
-function fenceTurnForNewGeneration(key, at) {
+function fenceTurnForNewGeneration(key, at, source = 'session-start') {
     const turn = exports.agentTurns.get(key);
+    // Issue #3798: reported whether or not a turn existed — the waiting episode
+    // is fenced by its own generation, not by the turn's.
+    const outcome = {
+        kind: 'generation-fenced',
+        source,
+        generation: toGenerationRef(currentGeneration(key)),
+        fencedTurnId: turn?.turnId ?? null,
+    };
     if (!turn)
-        return;
+        return outcome;
     evictDecisions(key, turn);
     // A turn that had ALREADY ended is left where it is, which means the fence in
     // `fencedTurn` hides it from here on. That asymmetry is deliberate: the
@@ -295,7 +338,7 @@ function fenceTurnForNewGeneration(key, at) {
     // nobody has typed into yet. Before #1930 the same protection came from
     // comparing the event's timestamp against the generation.
     if (turn.closedAt !== null)
-        return;
+        return outcome;
     // An OPEN turn is closed and carried across, so `capture --json` can say
     // `closedBy: 'generation'` rather than going quiet. `getStructuredSessionState`
     // reads that reason as "nothing is known", so it publishes no verdict either
@@ -304,6 +347,7 @@ function fenceTurnForNewGeneration(key, at) {
     turn.closedAt = at;
     turn.closedBy = 'generation';
     turn.generationAt = at;
+    return outcome;
 }
 /**
  * The turn transition: what one delivery does to {@link TurnRecord}
@@ -406,23 +450,32 @@ function applyTurnTransition(key, record) {
     // An event stamped before the current generation was produced by a process
     // that has been replaced. Refusing it here is what makes re-recording a stale
     // `user_prompt_submit` at its original timestamp a no-op.
-    if (generation !== null && record.at < generation)
-        return;
+    if (generation !== null && record.at < generation) {
+        if (record.event === 'stop')
+            return { kind: 'stop-rejected', reason: 'before-generation' };
+        if (record.event === 'session_end')
+            return { kind: 'session-end-rejected', reason: 'before-generation' };
+        return { kind: 'none' };
+    }
     switch (record.event) {
-        case 'user_prompt_submit':
+        case 'user_prompt_submit': {
             // Issue #3330: a queued notice the agent attached to its running turn
             // continues that turn; any other prompt is a new one.
-            openTurn(key, record, generation, { continueOpen: record.joinsOpenTurn === true });
+            const outcome = openTurn(key, record, 'user_prompt_submit', generation, {
+                continueOpen: record.joinsOpenTurn === true,
+            });
             releaseAllDecisions(key);
-            return;
-        case 'post_tool_use':
-            openTurn(key, record, generation, { continueOpen: true });
+            return outcome;
+        }
+        case 'post_tool_use': {
+            const outcome = openTurn(key, record, 'post_tool_use', generation, { continueOpen: true });
             // The tool call the dialog was gating has finished, so somebody answered
             // it (Issue #1726). This is the release #1725 could not have: it had no
             // event meaning "the human answered", only `Stop` meaning "the turn
             // ended", which can be minutes later.
             releaseAllDecisions(key);
-            return;
+            return outcome;
+        }
         case 'pre_tool_use':
             // Deliberately leaves the dialog alone (Issue #1726). It is the
             // `AskUserQuestion` invocation, and a picker being *about to be drawn* is
@@ -432,28 +485,26 @@ function applyTurnTransition(key, record) {
             // start of a turn when the agent's own `Stop` is the last thing that
             // ended one. See the `after its stop` row above.
             if (record.promptOpensTurns === true && endedByOwnStop(key))
-                return;
-            openTurn(key, record, generation, { continueOpen: true });
-            return;
+                return { kind: 'none' };
+            return openTurn(key, record, 'pre_tool_use', generation, { continueOpen: true });
         case 'stop':
-            applyStopToTurn(key, record, generation);
-            return;
-        case 'session_end':
-            applySessionEndToTurn(key, record);
+            return applyStopToTurn(key, record, generation);
+        case 'session_end': {
+            const outcome = applySessionEndToTurn(key, record);
             releaseAllDecisions(key);
-            return;
+            return outcome;
+        }
         case 'session_start':
             // The generation was opened by `recordAgentEvent` before this ran, and
             // `fenceTurnForNewGeneration` closed the turn with it. Nothing further:
             // the frame carries no verdict, so it is not the displayed event either.
-            return;
+            return { kind: 'none' };
         case 'notification':
-            applyNotificationToTurn(key, record, generation);
-            return;
+            return applyNotificationToTurn(key, record, generation);
         default:
             // exhaustive check: a new AgentEventType must decide its transition here
             record.event;
-            return;
+            return { kind: 'none' };
     }
 }
 /**
@@ -494,8 +545,10 @@ function displayOf(record) {
  *   this event's turn. False for `user_prompt_submit`, which IS a new turn —
  *   unless the source marked it as joining the running one (Issue #3330).
  */
-function openTurn(key, record, generation, { continueOpen }) {
+function openTurn(key, record, event, generation, { continueOpen }) {
     const turn = fencedTurn(key);
+    // Issue #3798: read before anything below rewrites the record.
+    const previous = describePrevious(turn, record.sessionId, record.at);
     const openHere = turn !== null &&
         turn.closedAt === null &&
         turn.openedAt !== null &&
@@ -506,7 +559,7 @@ function openTurn(key, record, generation, { continueOpen }) {
         // partway through. Learning it is what lets a later `stop` be matched.
         turn.sessionId ??= record.sessionId;
         turn.scraperCompletionPolls = 0;
-        return;
+        return { kind: 'continued', turnId: turn.turnId };
     }
     // A dialog-only record (openedAt null) is not a turn; its decisions belong to
     // the turn that is opening now, because that is when they were raised.
@@ -532,6 +585,7 @@ function openTurn(key, record, generation, { continueOpen }) {
         exports.reopenedTurns.set(key, { turnId: opened.turnId, replaced: turn });
         (0, agent_event_dedup_1.trimOldestEntries)(exports.reopenedTurns, agent_event_dedup_1.MAX_RECENT_EVENT_KEYS);
     }
+    return { kind: 'opened', turnId: opened.turnId, event, generation: toGenerationRef(generation), previous };
 }
 /**
  * Give a dropped copy's queued-notice mark its effect (Issue #3330).
@@ -590,6 +644,11 @@ function joinOpenTurnFromDuplicate(worktreeId, cliToolId, instanceId, record) {
         scraperCompletionPolls: 0,
     });
     exports.reopenedTurns.delete(key);
+    // Issue #3798: a wait that opened under the discarded turn belongs to the
+    // turn put back. Told through the sink — this runs outside `recordAgentEvent`.
+    globalThis.__agentEventTurnOutcomeSink?.({ worktreeId, cliToolId, instanceId }, [
+        { kind: 'restored', restoredTurnId: replaced.turnId, discardedTurnId: current.turnId },
+    ]);
     return true;
 }
 /**
@@ -604,15 +663,27 @@ function applyStopToTurn(key, record, generation) {
     const turn = fencedTurn(key);
     if (turn !== null && turn.closedAt === null && turn.openedAt !== null) {
         if (!(0, provisional_turn_1.closesTurn)(turn, record.sessionId))
-            return;
+            return { kind: 'stop-rejected', reason: 'other-session' };
         turn.closedAt = record.at;
         turn.closedBy = 'stop';
         turn.displayEvent = displayOf(record);
         releaseAllDecisions(key);
-        return;
+        return { kind: 'stopped', turnId: turn.turnId, generation: toGenerationRef(generation) };
+    }
+    const previous = describePrevious(turn, record.sessionId, record.at);
+    // Issue #3798: a dialog raised by one agent session is not ended by another
+    // session's stop. Both ids are needed to tell — a record or a stop with no id
+    // is read as the same session, as `closesTurn` reads it. opencode publishes
+    // `session.idle` for every session its server holds (#1758 §5.6).
+    if (previous.kind === 'dialog-only' &&
+        previous.sessionId !== null &&
+        record.sessionId !== null &&
+        previous.sessionId !== record.sessionId) {
+        return { kind: 'stop-rejected', reason: 'other-session' };
     }
+    const recordTurnId = nextTurnId(record.at);
     exports.agentTurns.set(key, {
-        turnId: nextTurnId(record.at),
+        turnId: recordTurnId,
         sessionId: record.sessionId,
         openedAt: null,
         closedAt: record.at,
@@ -623,6 +694,7 @@ function applyStopToTurn(key, record, generation) {
         scraperCompletionPolls: 0,
     });
     boundTurnMap();
+    return { kind: 'stop-without-turn', recordTurnId, generation: toGenerationRef(generation), previous };
 }
 /**
  * `session_end`: the agent session this instance was talking to is gone.
@@ -643,11 +715,12 @@ function applyStopToTurn(key, record, generation) {
 function applySessionEndToTurn(key, record) {
     const turn = fencedTurn(key);
     if (turn === null)
-        return;
+        return { kind: 'session-end-rejected', reason: 'no-turn' };
     if (!(0, provisional_turn_1.closesTurn)(turn, record.sessionId))
-        return;
+        return { kind: 'session-end-rejected', reason: 'other-session' };
     turn.closedAt = record.at;
     turn.closedBy = 'session_end';
+    return { kind: 'session-ended', turnId: turn.turnId };
 }
 /**
  * The notification rows of the transition table.
@@ -663,10 +736,9 @@ function applyNotificationToTurn(key, record, generation) {
             // reached the agent. There is no dialog and there never was one for a
             // human to answer — opening a record for it published `waiting` for the
             // whole of the tool call that followed (measured at eight seconds).
-            releaseSettledDecision(key, record);
-            return;
+            return releaseSettledDecision(key, record);
         }
-        openDecision(key, generation, {
+        const opened = openDecision(key, generation, {
             source: 'notification',
             at: record.at,
             message: record.message ?? null,
@@ -679,16 +751,17 @@ function applyNotificationToTurn(key, record, generation) {
             patterns: record.decisionPatterns ?? null,
             decisionId: record.decisionId ?? null,
             bootstrapDisplay: displayOf(record),
+            sessionId: record.sessionId,
         });
-        return;
+        return { kind: 'decision-opened', ...opened };
     }
     if (record.detail === agent_event_types_1.PERMISSION_REPLIED_DETAIL) {
         // Issue #1898. The agent's own statement that the dialog is gone — whoever
         // answered it. Not a word this build reads a status from, so it decides
         // nothing; all it does is retire the record.
         if (record.promptSettled === true)
-            releaseSettledDecision(key, record);
-        return;
+            return releaseSettledDecision(key, record);
+        return { kind: 'none' };
     }
     if (record.detail === 'idle_prompt') {
         // The agent reporting it is sitting at the composer waiting for input is the
@@ -697,10 +770,10 @@ function applyNotificationToTurn(key, record, generation) {
         const turn = fencedTurn(key);
         if (turn !== null && turn.closedAt === null) {
             turn.displayEvent = displayOf(record);
-            return;
+            return { kind: 'none' };
         }
         if (turn !== null)
-            return;
+            return { kind: 'none' };
         // Nothing to attach it to — the first thing this instance ever said, or the
         // first since a generation. It still carries a verdict (`ready`), and #1723
         // publishes it, so a display-only record is opened to hold it. `openedAt`
@@ -718,10 +791,11 @@ function applyNotificationToTurn(key, record, generation) {
             scraperCompletionPolls: 0,
         });
         boundTurnMap();
-        return;
+        return { kind: 'none' };
     }
     // An unrecognised notification type is not evidence of anything, and guessing
     // would be worse than the scraper.
+    return { kind: 'none' };
 }
 /**
  * Open, or refresh, a dialog record on this instance's turn.
@@ -736,7 +810,7 @@ function openDecision(key, generation, input) {
     if (turn === null) {
         turn = {
             turnId: nextTurnId(input.at),
-            sessionId: null,
+            sessionId: input.sessionId ?? null,
             openedAt: null,
             closedAt: null,
             closedBy: null,
@@ -754,7 +828,7 @@ function openDecision(key, generation, input) {
         // late. Re-open a dialog-only record rather than resurrecting the turn.
         turn = {
             turnId: nextTurnId(input.at),
-            sessionId: null,
+            sessionId: input.sessionId ?? null,
             openedAt: null,
             closedAt: null,
             closedBy: null,
@@ -766,6 +840,15 @@ function openDecision(key, generation, input) {
         exports.agentTurns.set(key, turn);
         boundTurnMap();
     }
+    else if (turn.openedAt === null && turn.sessionId === null) {
+        // A dialog-only record bootstrapped by a forecast with no session learns
+        // the session from the report that confirms it.
+        turn.sessionId = input.sessionId ?? null;
+    }
+    const opened = {
+        recordTurnId: turn.turnId,
+        recordKind: turn.openedAt !== null ? 'turn' : 'dialog-only',
+    };
     // Issue #1930 / S1: an id that fails validation is DISCARDED, not truncated —
     // a truncated id compares equal to a different id sharing its prefix, and the
     // reply to one approval would then retire another's record.
@@ -807,14 +890,14 @@ function openDecision(key, generation, input) {
             existing.source = 'notification';
             existing.confirmedAt ??= input.at;
         }
-        return;
+        return opened;
     }
     if (turn.pendingDecisions.length >= provisional_turn_1.MAX_PENDING_DECISIONS_PER_TURN) {
         // S14(d). Counted rather than dropped in silence: an agent raising more
         // approvals than this in one turn is a fact an operator has to be able to
         // see, and the oldest is the one a human has been looking at.
         (0, agent_event_dedup_1.dropsFor)(key).decisionOverflow += 1;
-        return;
+        return opened;
     }
     turn.pendingDecisions.push({
         decisionId,
@@ -827,6 +910,7 @@ function openDecision(key, generation, input) {
         scraperCorroborated: false,
         recorded: false,
     });
+    return opened;
 }
 /** Retire every dialog this instance was holding. */
 function releaseAllDecisions(key) {
@@ -846,15 +930,25 @@ function releaseAllDecisions(key) {
 function releaseSettledDecision(key, record) {
     const turn = fencedTurn(key);
     if (turn === null || turn.pendingDecisions.length === 0)
-        return;
+        return { kind: 'none' };
+    const before = turn.pendingDecisions.length;
     const settledId = record.decisionId === null || record.decisionId === undefined
         ? null
         : (0, provisional_turn_1.acceptExternalId)(record.decisionId);
     if (settledId === null) {
         turn.pendingDecisions = [];
-        return;
     }
-    turn.pendingDecisions = turn.pendingDecisions.filter((decision) => decision.decisionId !== null && decision.decisionId !== settledId);
+    else {
+        turn.pendingDecisions = turn.pendingDecisions.filter((decision) => decision.decisionId !== null && decision.decisionId !== settledId);
+    }
+    // Issue #3798: an explicit answer — the one release that ends a wait.
+    return {
+        kind: 'decision-answered',
+        recordTurnId: turn.turnId,
+        recordKind: turn.openedAt !== null ? 'turn' : 'dialog-only',
+        before,
+        remaining: turn.pendingDecisions.length,
+    };
 }
 /** Keep the turn map bounded the way every other map in this module is. */
 function boundTurnMap() {

package/dist/server/src/lib/session/cli-session.js

@@ -35,6 +35,14 @@ const session_status_options_1 = require("../../lib/tmux/session-status-options"
 const tmux_1 = require("../../lib/tmux/tmux");
 const tmux_session_surface_1 = require("./tmux-session-surface");
 const logger = (0, logger_1.createLogger)('cli-session');
+/** Tell the observer this capture runs for, if any, where its frame came from (Issue #3798). */
+function reportFrameMeta(meta) {
+    globalThis.__captureFrameMetaSink?.getStore()?.(meta);
+}
+/** Tell the observer this capture runs for, if any, whether its window cut the pane's top (Issue #3881 N4). */
+function reportHeadCut(headCut) {
+    globalThis.__captureHeadCutSink?.getStore()?.(headCut);
+}
 function getDefaultTransport() {
     return (0, polling_tmux_transport_1.getPollingTmuxTransport)();
 }
@@ -95,7 +103,11 @@ async function captureSessionOutput(worktreeId, cliToolId, lines = 1000, instanc
                 throw new Error(`${cliTool.name} session ${sessionName} does not exist`);
             }
             return await transport.captureSnapshot(sessionName, { startLine: -tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES });
-        });
+        }, 
+        // Issue #3798: this call's own frame, to the observer it runs for
+        reportFrameMeta, 
+        // Issue #3881 (third review N4): and whether the window cut its top
+        reportHeadCut);
         log.debug('captureSessionOutput:success', {
             actualLines: output.split('\n').length,
             lastFewLines: output.split('\n').slice(-3).join(' | '),
@@ -132,18 +144,25 @@ async function captureSessionOutputFresh(worktreeId, cliToolId, lines = 5000, in
     const transport = getDefaultTransport();
     // Issue #3734: snapshot the generation before the capture starts
     const generation = (0, tmux_capture_cache_1.getCaptureGeneration)(sessionName);
+    // Issue #3798: and the time, so the cache says when this frame was fetched,
+    // not when a slow capture came back
+    const fetchStartedAt = Date.now();
     try {
         const output = await transport.captureSnapshot(sessionName, { startLine: -lines });
         // Write back to cache if non-empty [SEC4-007]. Skip it when the session was
         // invalidated while waiting: the output may predate a send (Issue #3734).
         if (output.length > 0) {
             if ((0, tmux_capture_cache_1.isCaptureGenerationCurrent)(sessionName, generation)) {
-                (0, tmux_capture_cache_1.setCachedCapture)(sessionName, output, lines);
+                (0, tmux_capture_cache_1.setCachedCapture)(sessionName, output, lines, fetchStartedAt);
             }
         }
         else {
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         }
+        reportFrameMeta({ fetchStartedAt, source: 'fetched' });
+        const headCutSink = globalThis.__captureHeadCutSink?.getStore();
+        if (headCutSink)
+            headCutSink((0, tmux_capture_cache_1.sliceCutsHead)(output, lines));
         return (0, tmux_capture_cache_1.sliceOutput)(output, lines);
     }
     catch (error) {

package/dist/server/src/lib/session/composer-clear.js

@@ -30,13 +30,60 @@
  * frame back to the browser.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMPOSER_CLEAR_REDRAW_DELAY_MS = exports.MAX_COMPOSER_CLEAR_PASSES = void 0;
+exports.COMPOSER_CLEAR_REDRAW_DELAY_MS = exports.MAX_COMPOSER_CLEAR_PASSES = exports.findCodexLiveComposerRow = exports.codexDialogBelow = void 0;
+exports.isCodexPasteTokenOnly = isCodexPasteTokenOnly;
 exports.clearComposer = clearComposer;
 const tmux_1 = require("../../lib/tmux/tmux");
 const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
 const composer_text_1 = require("../../lib/detection/composer-text");
+Object.defineProperty(exports, "codexDialogBelow", { enumerable: true, get: function () { return composer_text_1.codexDialogBelow; } });
+Object.defineProperty(exports, "findCodexLiveComposerRow", { enumerable: true, get: function () { return composer_text_1.findCodexLiveComposerRow; } });
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('composer-clear');
+/**
+ * The composer as this loop reads it.
+ *
+ * {@link extractLiveComposerText} — the reading the unsent bar is drawn from
+ * (Issue #3927) — and for codex one more reading when it finds no
+ * composer (Issue #3906): a body of more paragraphs than the extractor's four
+ * blocks — the partly arrived paste the sender reads as `pasting` and withdraws
+ * through this function — is still a composer holding text. Only `content` is
+ * taken from that reading; anything else stays `no_composer`, so a frame this
+ * reading cannot vouch for is never reported as emptied.
+ *
+ * A composer the extractor does find is still not the live one when a dialog
+ * option is drawn below it ({@link codexDialogBelow}): that frame is
+ * `no_composer`, so no `C-e`+`C-u` goes into the dialog.
+ */
+function readClearComposer(capture, cliToolId) {
+    const read = (0, composer_text_1.extractLiveComposerText)(capture, cliToolId);
+    if (cliToolId !== 'codex' || read.state !== 'no_composer')
+        return read;
+    const rows = capture.split('\n');
+    const row = (0, composer_text_1.findCodexLiveComposerRow)(rows);
+    if (row < 0)
+        return read;
+    const held = (0, composer_text_1.readCodexComposerFrom)(rows, row);
+    return held.state === 'content' ? held : read;
+}
+/**
+ * A codex composer holding exactly one collapsed paste placeholder and nothing
+ * else (Issue #3937) — the one frame a pass sends `C-e`+`BSpace` for instead of
+ * `C-e`+`C-u` ({@link clearComposerPasteToken}).
+ *
+ * Anything more than the bare placeholder keeps the `C-e`+`C-u` pass, because
+ * none of it has been measured on a live codex: a placeholder with typed text
+ * after it (`C-e`+`BSpace` would eat the last typed character, not the
+ * placeholder), two placeholders, and a body quoting the placeholder's wording
+ * among other text. A body that is nothing but that wording typed out is not
+ * told apart here; one `BSpace` takes its `]`, and from the next read on it is
+ * ordinary text again — `C-e`+`C-u` — so the read-back still decides.
+ */
+const CODEX_PASTE_TOKEN_ONLY = /^\[Pasted Content \d+ chars?\]$/;
+/** Whether a pass over this reading should send `C-e`+`BSpace` (Issue #3937). */
+function isCodexPasteTokenOnly(read, cliToolId) {
+    return cliToolId === 'codex' && read.state === 'content' && CODEX_PASTE_TOKEN_ONLY.test(read.text.trim());
+}
 /**
  * Upper bound on `C-e`+`C-u` passes.
  *
@@ -67,15 +114,20 @@ async function clearComposer(sessionName, cliToolId, options = {}) {
     const delay = options.delay ?? defaultDelay;
     const maxPasses = options.maxPasses ?? exports.MAX_COMPOSER_CLEAR_PASSES;
     let passes = 0;
-    let result = (0, composer_text_1.extractComposerText)(await capture(sessionName), cliToolId);
+    let result = readClearComposer(await capture(sessionName), cliToolId);
     // Snapshot before the first pass: every later read shows less of it (a pass
     // eats one row), so this is the only moment the full text exists.
     const discardedText = result.state === 'content' ? result.text : '';
     while (result.state === 'content' && passes < maxPasses) {
-        await sendClear(sessionName);
+        if (isCodexPasteTokenOnly(result, cliToolId)) {
+            await (options.sendClearPasteToken ?? tmux_1.clearComposerPasteToken)(sessionName);
+        }
+        else {
+            await sendClear(sessionName);
+        }
         passes++;
         await delay(exports.COMPOSER_CLEAR_REDRAW_DELAY_MS);
-        result = (0, composer_text_1.extractComposerText)(await capture(sessionName), cliToolId);
+        result = readClearComposer(await capture(sessionName), cliToolId);
     }
     // Whatever happened above, the cached frame is now stale: the poller and the
     // WebSocket push both read through `captureSessionOutput`, and serving the