@steipete/oracle 0.15.1 → 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/scripts/test-browser.js

@@ -58,9 +58,9 @@ function firewallHint(host, devtoolsPort) {
         "Re-run ./runner pnpm test:browser after adding the rule.",
     ].join("\n");
 }
-async function fetchVersion(host, devtoolsPort) {
+async function fetchVersion(host, devtoolsPort, timeoutMs = 5000) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 5000);
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
         const res = await fetch(`http://${host}:${devtoolsPort}/json/version`, {
             signal: controller.signal,
@@ -77,6 +77,16 @@ async function fetchVersion(host, devtoolsPort) {
         clearTimeout(timer);
     }
 }
+async function waitForDevToolsShutdown(host, devtoolsPort) {
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        if (!(await fetchVersion(host, devtoolsPort, 250))) {
+            return;
+        }
+        await sleep(100);
+    }
+    throw new Error(`DevTools did not stop listening at ${host}:${devtoolsPort}`);
+}
 async function main() {
     console.log(`[browser-test] launching Chrome on ${targetHost}:${port} (headful)…`);
     const chrome = await launch({
@@ -89,6 +99,7 @@ async function main() {
         ok = await fetchVersion(targetHost, chrome.port);
     }
     await chrome.kill();
+    await waitForDevToolsShutdown(targetHost, chrome.port);
     if (ok) {
         console.log(`[browser-test] PASS: DevTools responding on ${targetHost}:${chrome.port}`);
         process.exit(0);

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

@@ -1,9 +1,61 @@
 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 readPositiveIntEnv(name, fallback) {
+    const raw = Number(process.env[name]);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
+}
+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 { state: next, terminal };
+}
 const THINKING_STATUS_LABELS = [
     "thinking",
     "pro thinking",
@@ -25,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".
@@ -52,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();
   };`;
@@ -109,7 +163,9 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
             if (source === "poll" &&
                 error instanceof Error &&
                 error.message === ASSISTANT_POLL_TIMEOUT_ERROR) {
-                evaluation = await evaluationPromise;
+                evaluationPromise.catch(() => undefined);
+                await terminateRuntimeExecution(Runtime);
+                throw error;
             }
             else if (source === "poll") {
                 throw error;
@@ -159,29 +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);
     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.
-        const candidateText = String(candidate?.text ?? "").trim();
-        if (stopVisible || completionVisible) {
-            logger(stopVisible
-                ? "Assistant still generating; waiting for completion"
-                : "Completion controls surfaced; confirming stable assistant response");
-            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");
     }
-    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({
@@ -243,13 +302,31 @@ async function recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex
     if (recoveryTimeoutMs === 0) {
         return null;
     }
+    const recoveryStartedAt = Date.now();
     const recovered = await waitForCondition(async () => {
         const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId);
         return normalizeAssistantSnapshot(snapshot);
     }, recoveryTimeoutMs, 400);
     if (recovered) {
-        logger("Recovered assistant response via polling fallback");
-        return recovered;
+        // 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;
+        }
+        // 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;
@@ -337,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) {
@@ -348,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 = currentLength > 0 && currentLength < 16;
-            const mediumAnswer = currentLength >= 16 && 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 || 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);
     }
@@ -427,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 = Array.from(document.querySelectorAll('${CONVERSATION_TURN_SELECTOR}'));
-        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);
@@ -472,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()) {
@@ -490,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) {
@@ -557,7 +657,6 @@ function buildAssistantSnapshotExpression(minTurnIndex, expectedConversationId)
 }
 function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConversationId) {
     const selectorsLiteral = JSON.stringify(ANSWER_SELECTORS);
-    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
@@ -570,7 +669,6 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
     const SELECTORS = ${selectorsLiteral};
     const STOP_SELECTOR = ${JSON.stringify(STOP_CONTROL_SELECTOR)};
     const FINISHED_SELECTOR = '${FINISHED_ACTIONS_SELECTOR}';
-    const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const EXPECTED_CONVERSATION_ID = ${expectedConversationLiteral};
     // Learned: settling avoids capturing mid-stream HTML; keep short.
@@ -593,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) => {
@@ -693,7 +792,7 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
 
     // Check if the last assistant turn has finished (scoped to avoid detecting old turns).
     const isLastAssistantTurnFinished = () => {
-      const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+      const turns = ${buildConversationTurnListExpression()};
       let lastAssistantTurn = null;
       for (let i = turns.length - 1; i >= 0; i--) {
         if (isAssistantTurn(turns[i])) {
@@ -717,8 +816,8 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
       // Learned: long streaming responses (esp. thinking models) can pause mid-stream;
       // use progressively longer windows to avoid truncation (#71).
       const initialLength = snapshot?.text?.length ?? 0;
-      const shortAnswer = initialLength > 0 && initialLength < 16;
-      const mediumAnswer = initialLength >= 16 && initialLength < 40;
+      const shortAnswer = initialLength > 0 && initialLength < ${MIN_CONFIDENT_ANSWER_LENGTH};
+      const mediumAnswer = initialLength >= ${MIN_CONFIDENT_ANSWER_LENGTH} && initialLength < 40;
       const longAnswer = initialLength >= 40 && initialLength < 500;
       const settleWindowMs = shortAnswer ? 12_000 : mediumAnswer ? 5_000 : longAnswer ? 8_000 : 10_000;
       const settleIntervalMs = 400;
@@ -759,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;
         }
       }
@@ -792,11 +898,9 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConver
   })()`;
 }
 function buildAssistantExtractor(functionName) {
-    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     return `const ${functionName} = () => {
     ${buildClickDispatcher()}
-    const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const isAssistantTurn = (node) => {
       if (!(node instanceof HTMLElement)) return false;
@@ -832,7 +936,7 @@ function buildAssistantExtractor(functionName) {
       }
     };
 
-    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turns = ${buildConversationTurnListExpression()};
     for (let index = turns.length - 1; index >= 0; index -= 1) {
       const turn = turns[index];
       if (!isAssistantTurn(turn)) {
@@ -867,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 };
@@ -916,29 +1020,32 @@ function buildMarkdownFallbackExtractor(minTurnLiteral) {
       }
     }
     if (!root) return null;
-    const CONVERSATION_SELECTOR = '${CONVERSATION_TURN_SELECTOR}';
-    const turnNodes = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turnNodes = ${buildConversationTurnListExpression()};
     const hasTurns = turnNodes.length > 0;
     const resolveTurnIndex = (node) => {
-      const turn = node?.closest?.(CONVERSATION_SELECTOR);
-      if (!turn) return null;
-      const idx = turnNodes.indexOf(turn);
+      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);
@@ -1009,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;
   })`;
@@ -1050,7 +1164,7 @@ function buildCopyExpression(meta) {
         if (testId.includes('assistant')) return true;
         return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
       };
-      const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+      const turns = ${buildConversationTurnListExpression()};
       for (let i = turns.length - 1; i >= 0; i -= 1) {
         const turn = turns[i];
         if (!isAssistantTurn(turn)) continue;

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

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { CONVERSATION_TURN_SELECTOR, INPUT_SELECTORS, SEND_BUTTON_SELECTORS, UPLOAD_STATUS_SELECTORS, } from "../constants.js";
+import { INPUT_SELECTORS, SEND_BUTTON_SELECTORS, UPLOAD_STATUS_SELECTORS } from "../constants.js";
+import { buildConversationTurnListExpression } from "../conversationTurns.js";
 import { delay } from "../utils.js";
 import { logDomFailure } from "../domDebug.js";
 import { transferAttachmentViaDataTransfer } from "./attachmentDataTransfer.js";
@@ -1594,14 +1595,12 @@ export async function waitForUserTurnAttachments(Runtime, expectedNames, timeout
     throw new Error("Attachment was not present on the sent user message.");
 }
 function buildUserTurnAttachmentExpression(options) {
-    const conversationSelectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const minTurnLiteral = options.minTurnIndex === null ? "null" : String(options.minTurnIndex);
     const expectedPromptLiteral = JSON.stringify(options.expectedPromptPrefix);
     const expectedConversationLiteral = options.expectedConversationId
         ? JSON.stringify(options.expectedConversationId)
         : "null";
     return `(() => {
-    const CONVERSATION_SELECTOR = ${conversationSelectorLiteral};
     const MIN_TURN_INDEX = ${minTurnLiteral};
     const EXPECTED_PROMPT_PREFIX = ${expectedPromptLiteral};
     const EXPECTED_CONVERSATION_ID = ${expectedConversationLiteral};
@@ -1614,7 +1613,7 @@ function buildUserTurnAttachmentExpression(options) {
     ) {
       return { ok: false, conversationMismatch: true };
     }
-    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    const turns = ${buildConversationTurnListExpression()};
     const userTurns = turns.map((node, index) => ({ node, index })).filter(({ node }) => {
       const attr = (node.getAttribute('data-message-author-role') || node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();
       if (attr === 'user') return true;