@steipete/oracle 0.15.2 → 0.16.0

package/dist/bin/oracle-cli.js

@@ -227,7 +227,7 @@ program
     .addOption(new Option("--copy-markdown", "Copy the assembled markdown bundle to the clipboard; pair with --render to print it too.").default(false))
     .addOption(new Option("--copy").hideHelp().default(false))
     .option("-s, --slug <words>", "Custom session slug (3-5 words).")
-    .option("-m, --model <model>", 'Model to target (gpt-5.5-pro default). Also gpt-5.5, gpt-5.4-pro, gpt-5.4, gpt-5.1-pro, gpt-5-pro, gpt-5.1, gpt-5.1-codex API-only, gpt-5.2, gpt-5.2-instant, gpt-5.2-pro, gemini-3.1-flash-lite, gemini-3.5-flash, gemini-3.1-pro, legacy gemini-3-pro, claude-4.6-sonnet, claude-4.1-opus, or ChatGPT labels like "5.5 Pro" / "5.2 Thinking" for browser runs).', normalizeModelOption)
+    .option("-m, --model <model>", 'Model to target (gpt-5.5-pro default). GPT-5.6 aliases: gpt-5.6 and gpt-5.6-sol (OpenAI API or ChatGPT browser). Also gpt-5.5, gpt-5.4-pro, gpt-5.4, gpt-5.1-pro, gpt-5-pro, gpt-5.1, gpt-5.1-codex API-only, gpt-5.2, gpt-5.2-instant, gpt-5.2-pro, gemini-3.1-flash-lite, gemini-3.5-flash, gemini-3.1-pro, legacy gemini-3-pro, claude-4.6-sonnet, claude-4.1-opus, or ChatGPT labels like "5.5 Pro" / "5.2 Thinking" for browser runs).', normalizeModelOption)
     .addOption(new Option("--models <models>", 'Comma-separated API model list to query in parallel (e.g., "gpt-5.5-pro,gemini-3-pro").')
     .argParser(collectModelList)
     .default([]))

package/dist/src/browser/actions/assistantResponse.js

@@ -1,19 +1,60 @@
 import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, COPY_BUTTON_SELECTOR, FINISHED_ACTIONS_SELECTOR, STOP_BUTTON_SELECTORS, } from "../constants.js";
 import { buildConversationTurnListExpression } from "../conversationTurns.js";
+import { buildThinkingActivePredicateJs, readThinkingActivity } from "./thinkingStatus.js";
 import { delay } from "../utils.js";
 import { logDomFailure, logConversationSnapshot, buildConversationDebugExpression, } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
 const ASSISTANT_POLL_TIMEOUT_ERROR = "assistant-response-watchdog-timeout";
 const STOP_CONTROL_SELECTOR = STOP_BUTTON_SELECTORS.join(", ");
+// Still used by the in-page settle heuristic's length buckets (see buildResponseObserverExpression).
 const MIN_CONFIDENT_ANSWER_LENGTH = 16;
-function isImplausiblyShortAnswer(candidateLength) {
-    return candidateLength > 0 && candidateLength < MIN_CONFIDENT_ANSWER_LENGTH;
+function readPositiveIntEnv(name, fallback) {
+    const raw = Number(process.env[name]);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
 }
-export function shouldConfirmAssistantCompletion(args) {
-    if (args.stopVisible || args.completionVisible) {
-        return true;
+const TERMINAL_GATE_CONFIG = {
+    barConfirmCycles: readPositiveIntEnv("ORACLE_BAR_CONFIRM_CYCLES", 3),
+    minStableMs: readPositiveIntEnv("ORACLE_TERMINAL_MIN_STABLE_MS", 1_200),
+};
+export function createTerminalGateState(now) {
+    return {
+        lastKey: "",
+        lastChangeAt: now,
+        barStableCycles: 0,
+        seen: false,
+    };
+}
+// Pure, unit-testable per-cycle classifier. Feed it one sample every poll; when it returns
+// terminal:true the capture is proven complete and safe to finalize.
+export function classifyTurnTerminal(state, sample, config) {
+    const changed = !state.seen || sample.contentKey !== state.lastKey;
+    const lastChangeAt = changed ? sample.now : state.lastChangeAt;
+    // proofA debounce: weak/stale sidecar evidence may be overridden, but strong live activity
+    // must reset the debounce. It also resets on ANY content change so a bar that appears while
+    // the answer is still rendering (the transient-bar / first-tokens race) cannot finalize.
+    const barStableCycles = sample.barVisible && !sample.stopVisible && !sample.strongThinkingActive && !changed
+        ? state.barStableCycles + 1
+        : 0;
+    const next = {
+        lastKey: sample.contentKey,
+        lastChangeAt,
+        barStableCycles,
+        seen: true,
+    };
+    let terminal = false;
+    if (!sample.stopVisible && sample.len > 0) {
+        const stableMs = sample.now - lastChangeAt;
+        // Debounced action bar AND content stable for a minimum time. The time-stability
+        // requirement guards the documented race where finished-action controls surface while only
+        // the first tokens have rendered. Weak sidecar evidence cannot hang a finished turn, but
+        // strong live activity vetoes this proof and restarts its debounce.
+        terminal =
+            sample.barVisible &&
+                !sample.strongThinkingActive &&
+                barStableCycles >= config.barConfirmCycles &&
+                stableMs >= config.minStableMs;
     }
-    return isImplausiblyShortAnswer(args.candidateLength);
+    return { state: next, terminal };
 }
 const THINKING_STATUS_LABELS = [
     "thinking",
@@ -36,12 +77,14 @@ function matchesThinkingStatusLabel(trimmed) {
         return false;
     if (THINKING_STATUS_LABELS.includes(trimmed))
         return true;
-    if (trimmed.startsWith("thought for ") && trimmed.length <= 40)
+    // includes, not startsWith: the completed summary can carry a heading prefix
+    // ("Reasoning Thought for 12s"); the length cap keeps real answers out.
+    if (trimmed.includes("thought for ") && trimmed.length <= 40)
         return true;
     return trimmed.startsWith("pro thinking") && trimmed.length <= 40;
 }
-function isAnswerNowPlaceholderText(normalized) {
-    const text = normalized.trim();
+export function isAnswerNowPlaceholderText(value) {
+    const text = value.toLowerCase().replace(/\s+/g, " ").trim();
     if (!text)
         return false;
     // Learned: "Pro thinking" shows a placeholder turn that contains "Answer now".
@@ -63,7 +106,7 @@ function buildActiveThinkingStatusPredicateJs(fnName) {
     const labels = ${labelsLiteral};
     const matches =
       labels.includes(normalized) ||
-      (normalized.startsWith('thought for ') && normalized.length <= 40) ||
+      (normalized.includes('thought for ') && normalized.length <= 40) ||
       (normalized.startsWith('pro thinking') && normalized.length <= 40);
     return matches && isStopControlVisible();
   };`;
@@ -172,39 +215,32 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
         logger("Captured assistant generated image response");
         return candidate;
     }
-    // The evaluation path can race ahead of completion. If ChatGPT is still streaming, wait for the watchdog poller.
+    // The observer/refresh path can race ahead of true completion: a settled GPT-5.5 Pro
+    // preamble (or any mid-stream capture) looks done for a moment before the reasoning/tool
+    // phase begins. Re-confirm EVERY captured text through the terminal-only poller, which
+    // finalizes only on positive proof (a debounced action bar, or a quiet window with no
+    // active thinking). We deliberately drop the old ">= candidate length" acceptance: the
+    // poller is turn-scoped (minTurnIndex), so whatever it proves terminal is the right turn,
+    // even when the real answer is shorter than a verbose preamble.
     const elapsedMs = Date.now() - start;
     const remainingMs = Math.max(0, timeoutMs - elapsedMs);
-    const candidateText = String(candidate?.text ?? "").trim();
-    const suspiciouslyShort = isImplausiblyShortAnswer(candidateText.length);
     if (remainingMs > 0) {
-        const [stopVisible, completionVisible] = await Promise.all([
-            isStopButtonVisible(Runtime),
-            isCompletionVisible(Runtime),
-        ]);
-        // Completion controls can appear briefly while Pro is still replacing its thinking UI.
-        // Confirm every capture from that transition with the stability-based watchdog; a
-        // partial first paragraph can be arbitrarily long.
-        if (shouldConfirmAssistantCompletion({
-            candidateLength: candidateText.length,
-            stopVisible,
-            completionVisible,
-        })) {
-            logger(stopVisible
-                ? "Assistant still generating; waiting for completion"
-                : completionVisible
-                    ? "Completion controls surfaced; confirming stable assistant response"
-                    : "Captured an implausibly short response; confirming it is not a mid-stream capture");
-            const completed = await pollAssistantCompletion(Runtime, remainingMs, minTurnIndex, expectedConversationId);
-            if (completed && String(completed.text ?? "").trim().length >= candidateText.length) {
-                return completed;
-            }
+        logger("Confirming the capture is terminal (not a mid-stream/preamble capture)");
+        const completed = await pollAssistantCompletion(Runtime, remainingMs, minTurnIndex, expectedConversationId);
+        if (completed) {
+            return completed;
         }
+        // Could not prove completion within the budget: refuse rather than finalize a possibly
+        // incomplete capture. A clean, fast failure is recoverable (retry/salvage) and never
+        // ships a preamble as if it were the answer.
+        await logDomFailure(Runtime, logger, "assistant-response-unconfirmed");
+        throw new Error("assistant-response could not be confirmed complete before timeout; refusing to finalize a possibly-incomplete capture");
     }
-    if (suspiciouslyShort) {
-        throw new Error("assistant-response short capture could not be confirmed before timeout; refusing to finalize it");
-    }
-    return candidate;
+    // Budget already exhausted before we could confirm: refuse rather than fall through and ship
+    // an unconfirmed capture. A settled preamble that arrived near the deadline must not be
+    // finalized just because there was no time left to prove it terminal.
+    await logDomFailure(Runtime, logger, "assistant-response-unconfirmed");
+    throw new Error("assistant-response could not be confirmed complete before the deadline; refusing to finalize a possibly-incomplete capture");
 }
 export async function readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId) {
     const { result } = await Runtime.evaluate({
@@ -272,13 +308,25 @@ async function recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex
         return normalizeAssistantSnapshot(snapshot);
     }, recoveryTimeoutMs, 400);
     if (recovered) {
-        if (isImplausiblyShortAnswer(recovered.text.length)) {
-            logger("Recovered an implausibly short response; waiting for completion proof");
-            const remainingMs = Math.max(0, recoveryTimeoutMs - (Date.now() - recoveryStartedAt));
-            return pollAssistantCompletion(Runtime, remainingMs, minTurnIndex, expectedConversationId);
+        // Route EVERY recovered snapshot through the terminal-only poller (not just short ones):
+        // a recovered long preamble is exactly the raw-return bug this gate exists to prevent.
+        logger("Recovered a candidate response; confirming it is terminal before finalizing");
+        const remainingMs = Math.max(0, recoveryTimeoutMs - (Date.now() - recoveryStartedAt));
+        if (remainingMs > 0) {
+            const confirmed = await pollAssistantCompletion(Runtime, remainingMs, minTurnIndex, expectedConversationId);
+            if (confirmed) {
+                logger("Recovered and confirmed assistant response via polling fallback");
+                return confirmed;
+            }
+            // Unconfirmable within budget: refuse (return null) so the caller fails fast instead
+            // of finalizing a possibly-incomplete recovered capture.
+            await logConversationSnapshot(Runtime, logger).catch(() => undefined);
+            return null;
         }
-        logger("Recovered assistant response via polling fallback");
-        return recovered;
+        // No confirmation time left: refuse rather than return the unconfirmed recovered snapshot
+        // (returning it raw would reopen the recovered-long-preamble leak this gate closes).
+        await logConversationSnapshot(Runtime, logger).catch(() => undefined);
+        return null;
     }
     await logConversationSnapshot(Runtime, logger).catch(() => undefined);
     return null;
@@ -366,9 +414,7 @@ async function terminateRuntimeExecution(Runtime) {
 }
 async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expectedConversationId, abortSignal) {
     const watchdogDeadline = Date.now() + timeoutMs;
-    let previousLength = 0;
-    let stableCycles = 0;
-    let lastChangeAt = Date.now();
+    let gate = createTerminalGateState(Date.now());
     while (Date.now() < watchdogDeadline) {
         // Check abort signal to stop polling when another path won the race
         if (abortSignal?.aborted) {
@@ -377,44 +423,34 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expecte
         const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId);
         const normalized = normalizeAssistantSnapshot(snapshot);
         if (normalized) {
-            const currentLength = normalized.text.length;
-            if (currentLength > previousLength) {
-                previousLength = currentLength;
-                stableCycles = 0;
-                lastChangeAt = Date.now();
-            }
-            else {
-                stableCycles += 1;
+            // Generated-image answers stream no text and mount no action bar; accept immediately.
+            if (isGeneratedImageAssistantAnswer(normalized)) {
+                return normalized;
             }
-            const [stopVisible, completionVisible] = await Promise.all([
+            const [stopVisible, barVisible, thinkingActivity] = await Promise.all([
                 isStopButtonVisible(Runtime),
-                isCompletionVisible(Runtime),
+                isCompletionVisible(Runtime, normalized.meta, minTurnIndex),
+                readThinkingActivity(Runtime),
             ]);
-            if (isGeneratedImageAssistantAnswer(normalized)) {
+            const decision = classifyTurnTerminal(gate, {
+                now: Date.now(),
+                len: normalized.text.length,
+                // Fingerprint = turn/message identity + the full text, so a same-length rewrite, a
+                // shorter final answer replacing a longer preamble, or a new turn all count as change.
+                contentKey: `${normalized.meta.messageId ?? normalized.meta.turnId ?? ""}::${normalized.text}`,
+                stopVisible,
+                barVisible,
+                strongThinkingActive: thinkingActivity.strong,
+            }, TERMINAL_GATE_CONFIG);
+            gate = decision.state;
+            if (decision.terminal) {
                 return normalized;
             }
-            const shortAnswer = isImplausiblyShortAnswer(currentLength);
-            const mediumAnswer = currentLength >= MIN_CONFIDENT_ANSWER_LENGTH && currentLength < 40;
-            const longAnswer = currentLength >= 40 && currentLength < 500;
-            // Learned: short answers need a longer stability window or they truncate.
-            // Learned: long streaming responses (esp. thinking models) can pause mid-stream;
-            // use progressively longer windows to avoid truncation (#71).
-            const completionStableTarget = shortAnswer ? 12 : mediumAnswer ? 8 : longAnswer ? 6 : 8;
-            const requiredStableCycles = shortAnswer ? 12 : mediumAnswer ? 8 : longAnswer ? 8 : 10;
-            const stableMs = Date.now() - lastChangeAt;
-            const minStableMs = shortAnswer ? 8000 : mediumAnswer ? 1200 : longAnswer ? 2000 : 3000;
-            // Require stop button to disappear before treating completion as final.
-            if (!stopVisible) {
-                const stableEnough = stableCycles >= requiredStableCycles && stableMs >= minStableMs;
-                const completionEnough = completionVisible && stableCycles >= completionStableTarget && stableMs >= minStableMs;
-                if (completionEnough || (!shortAnswer && stableEnough)) {
-                    return normalized;
-                }
-            }
         }
         else {
-            previousLength = 0;
-            stableCycles = 0;
+            // The turn disappeared/reset (navigation, re-render): restart the gate so a stale
+            // action-bar debounce cannot carry over onto a fresh turn.
+            gate = createTerminalGateState(Date.now());
         }
         await delay(400);
     }
@@ -456,43 +492,70 @@ function buildStopButtonVisibilityPredicateJs(fnName) {
   };`;
 }
 export const buildStopButtonVisibilityExpressionForTest = buildStopButtonVisibilityExpression;
-async function isCompletionVisible(Runtime) {
+function buildCompletionVisibilityExpression(meta, minTurnIndex) {
+    const expectedMessageId = meta.messageId ? JSON.stringify(meta.messageId) : "null";
+    const expectedTurnId = meta.turnId ? JSON.stringify(meta.turnId) : "null";
+    const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
+        ? Math.floor(minTurnIndex)
+        : -1;
+    return `(() => {
+    const EXPECTED_MESSAGE_ID = ${expectedMessageId};
+    const EXPECTED_TURN_ID = ${expectedTurnId};
+    const MIN_TURN_INDEX = ${minTurnLiteral};
+    // Find the LAST assistant turn to check completion status. Must match the same logic as
+    // buildAssistantExtractor, then correlate the controls to the sampled response.
+    const ASSISTANT_SELECTOR = '${ASSISTANT_ROLE_SELECTOR}';
+    const isAssistantTurn = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const turnAttr = (node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();
+      if (turnAttr === 'assistant') return true;
+      const role = (node.getAttribute('data-message-author-role') || node.dataset?.messageAuthorRole || '').toLowerCase();
+      if (role === 'assistant') return true;
+      const testId = (node.getAttribute('data-testid') || '').toLowerCase();
+      if (testId.includes('assistant')) return true;
+      return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
+    };
+
+    const turns = ${buildConversationTurnListExpression()};
+    let lastAssistantTurn = null;
+    let lastAssistantIndex = -1;
+    for (let i = turns.length - 1; i >= 0; i--) {
+      if (isAssistantTurn(turns[i])) {
+        lastAssistantTurn = turns[i];
+        lastAssistantIndex = i;
+        break;
+      }
+    }
+    if (!lastAssistantTurn) return false;
+
+    const hasExpectedIdentity = Boolean(EXPECTED_MESSAGE_ID || EXPECTED_TURN_ID);
+    if (hasExpectedIdentity) {
+      const identityNodes = [
+        lastAssistantTurn,
+        ...Array.from(lastAssistantTurn.querySelectorAll('[data-message-id], [data-testid]')),
+      ];
+      const identityMatches = identityNodes.some((node) =>
+        (EXPECTED_MESSAGE_ID && node.getAttribute?.('data-message-id') === EXPECTED_MESSAGE_ID) ||
+        (EXPECTED_TURN_ID && node.getAttribute?.('data-testid') === EXPECTED_TURN_ID),
+      );
+      if (!identityMatches) return false;
+    } else if (MIN_TURN_INDEX < 0 || lastAssistantIndex < MIN_TURN_INDEX) {
+      // Fallback/project snapshots without an identity may use the new-turn baseline, but an
+      // uncorrelated persistent action bar from an older turn must never prove completion.
+      return false;
+    }
+
+    if (lastAssistantTurn.querySelector('${FINISHED_ACTIONS_SELECTOR}')) return true;
+    const markdowns = lastAssistantTurn.querySelectorAll('.markdown');
+    return Array.from(markdowns).some((node) => (node.textContent || '').trim() === 'Done');
+  })()`;
+}
+async function isCompletionVisible(Runtime, meta, minTurnIndex) {
+    if (hasScopedCompletionProof(meta))
+        return true;
     try {
         const { result } = await Runtime.evaluate({
-            expression: `(() => {
-        // Find the LAST assistant turn to check completion status
-        // Must match the same logic as buildAssistantExtractor for consistency
-        const ASSISTANT_SELECTOR = '${ASSISTANT_ROLE_SELECTOR}';
-        const isAssistantTurn = (node) => {
-          if (!(node instanceof HTMLElement)) return false;
-          const turnAttr = (node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();
-          if (turnAttr === 'assistant') return true;
-          const role = (node.getAttribute('data-message-author-role') || node.dataset?.messageAuthorRole || '').toLowerCase();
-          if (role === 'assistant') return true;
-          const testId = (node.getAttribute('data-testid') || '').toLowerCase();
-          if (testId.includes('assistant')) return true;
-          return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
-        };
-
-        const turns = ${buildConversationTurnListExpression()};
-        let lastAssistantTurn = null;
-        for (let i = turns.length - 1; i >= 0; i--) {
-          if (isAssistantTurn(turns[i])) {
-            lastAssistantTurn = turns[i];
-            break;
-          }
-        }
-        if (!lastAssistantTurn) {
-          return false;
-        }
-        // Check if the last assistant turn has finished action buttons (copy, thumbs up/down, share)
-        if (lastAssistantTurn.querySelector('${FINISHED_ACTIONS_SELECTOR}')) {
-          return true;
-        }
-        // Also check for "Done" text in the last assistant turn's markdown
-        const markdowns = lastAssistantTurn.querySelectorAll('.markdown');
-        return Array.from(markdowns).some((n) => (n.textContent || '').trim() === 'Done');
-      })()`,
+            expression: buildCompletionVisibilityExpression(meta, minTurnIndex),
             returnByValue: true,
         });
         return Boolean(result?.value);
@@ -501,6 +564,10 @@ async function isCompletionVisible(Runtime) {
         return false;
     }
 }
+export function hasScopedCompletionProof(meta) {
+    return meta.completionVisible === true;
+}
+export const buildCompletionVisibilityExpressionForTest = buildCompletionVisibilityExpression;
 function normalizeAssistantSnapshot(snapshot) {
     const text = snapshot?.text ? cleanAssistantText(snapshot.text) : "";
     if (!text.trim()) {
@@ -519,7 +586,11 @@ function normalizeAssistantSnapshot(snapshot) {
     return {
         text,
         html: snapshot?.html ?? undefined,
-        meta: { turnId: snapshot?.turnId ?? undefined, messageId: snapshot?.messageId ?? undefined },
+        meta: {
+            turnId: snapshot?.turnId ?? undefined,
+            messageId: snapshot?.messageId ?? undefined,
+            ...(snapshot?.completionVisible === true ? { completionVisible: true } : {}),
+        },
     };
 }
 function isGeneratedImageAssistantAnswer(answer) {
@@ -620,6 +691,7 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
       return normalized.includes('answer now') && (normalized.includes('pro thinking') || normalized.includes('chatgpt said'));
     };
     ${buildActiveThinkingStatusPredicateJs("isActiveThinkingStatus")}
+    ${buildThinkingActivePredicateJs("isThinkingActiveNow")}
 
     // Helper to detect assistant turns - must match buildAssistantExtractor logic for consistency.
     const isAssistantTurn = (node) => {
@@ -786,8 +858,15 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
         }
         const stopVisible = Boolean(document.querySelector(STOP_SELECTOR));
         const finishedVisible = isLastAssistantTurnFinished();
+        // Defense in depth (the node side re-confirms every capture): never settle on a
+        // stable-but-quiet candidate while the model is actively thinking/generating, so the
+        // observer does not hand a settled preamble to the node path during the reasoning gap.
+        const thinkingActiveNow = isThinkingActiveNow();
 
-        if (finishedVisible || (!stopVisible && stableCycles >= stableTarget)) {
+        if (
+          finishedVisible ||
+          (!stopVisible && !thinkingActiveNow && stableCycles >= stableTarget)
+        ) {
           break;
         }
       }
@@ -892,7 +971,7 @@ function buildAssistantExtractor(functionName) {
         normalizedText === 'edit' ||
         normalizedText === 'stopped thinking' ||
         normalizedText === 'stopped thinking edit' ||
-        /^thought for \\d+(?:\\.\\d+)?\\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\\s+edit$/.test(normalizedText);
+        /^(?:reasoning\\s+|pro thinking\\s+)?thought for \\d+(?:\\.\\d+)?\\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\\s+edit$/.test(normalizedText);
       if (generatedImages.length > 0 && imageOnlyChrome) {
         const label = generatedImages.length === 1 ? 'Generated image.' : \`Generated \${generatedImages.length} images.\`;
         return { text: label, html: messageRoot?.innerHTML ?? html, messageId, turnId, turnIndex: index };
@@ -947,20 +1026,26 @@ function buildMarkdownFallbackExtractor(minTurnLiteral) {
       const idx = turnNodes.findIndex((turn) => turn === node || turn.contains?.(node));
       return idx >= 0 ? idx : null;
     };
+    const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+    const collectLastUser = (scope) => {
+      if (!scope?.querySelectorAll) return null;
+      const userTurns = Array.from(scope.querySelectorAll('[data-message-author-role="user"], [data-turn="user"]'));
+      return userTurns[userTurns.length - 1] ?? null;
+    };
+    const lastUser = collectLastUser(root) || collectLastUser(document);
+    const userText = lastUser ? normalize(lastUser.innerText || lastUser.textContent || '') : '';
+    const isAfterCurrentUser = (node) => {
+      if (!lastUser || typeof lastUser.compareDocumentPosition !== 'function') return false;
+      // Node.DOCUMENT_POSITION_FOLLOWING = 4. Use the numeric bit so the injected expression
+      // also works in stripped browser test contexts without a global Node constructor.
+      return Boolean(lastUser.compareDocumentPosition(node) & 4);
+    };
     const isAfterMinTurn = (node) => {
       if (__minTurn === null) return true;
-      if (!hasTurns) return true;
+      if (!hasTurns) return isAfterCurrentUser(node);
       const idx = resolveTurnIndex(node);
       return idx !== null && idx >= __minTurn;
     };
-    const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
-    const collectUserText = (scope) => {
-      if (!scope?.querySelectorAll) return '';
-      const userTurns = Array.from(scope.querySelectorAll('[data-message-author-role="user"], [data-turn="user"]'));
-      const lastUser = userTurns[userTurns.length - 1];
-      return lastUser ? normalize(lastUser.innerText || lastUser.textContent || '') : '';
-    };
-    const userText = collectUserText(root) || collectUserText(document);
     const isUserEcho = (text) => {
       if (!userText) return false;
       const normalized = normalize(text);
@@ -1031,7 +1116,14 @@ function buildMarkdownFallbackExtractor(minTurnLiteral) {
       if (isUserEcho(text)) continue;
       const html = node.innerHTML ?? '';
       const turnIndex = resolveTurnIndex(node);
-      return { text, html, messageId: null, turnId: null, turnIndex };
+      return {
+        text,
+        html,
+        messageId: null,
+        turnId: null,
+        turnIndex,
+        completionVisible: actionMarkdowns.includes(node),
+      };
     }
     return null;
   })`;