@steipete/oracle 0.8.4 → 0.8.6

package/dist/src/bridge/connection.js

@@ -0,0 +1,103 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export function normalizeHostPort(hostname, port) {
+    const trimmed = hostname.trim();
+    const unwrapped = trimmed.startsWith('[') && trimmed.endsWith(']') ? trimmed.slice(1, -1) : trimmed;
+    if (unwrapped.includes(':')) {
+        return `[${unwrapped}]:${port}`;
+    }
+    return `${unwrapped}:${port}`;
+}
+export function parseHostPort(raw) {
+    const target = raw.trim();
+    if (!target) {
+        throw new Error('Expected host:port but received an empty value.');
+    }
+    const ipv6Match = target.match(/^\[(.+)]:(\d+)$/);
+    let hostname;
+    let portSegment;
+    if (ipv6Match) {
+        hostname = ipv6Match[1]?.trim();
+        portSegment = ipv6Match[2]?.trim();
+    }
+    else {
+        const lastColon = target.lastIndexOf(':');
+        if (lastColon === -1) {
+            throw new Error(`Invalid host:port format: ${target}. Expected host:port (IPv6 must use [host]:port notation).`);
+        }
+        hostname = target.slice(0, lastColon).trim();
+        portSegment = target.slice(lastColon + 1).trim();
+        if (hostname.includes(':')) {
+            throw new Error(`Invalid host:port format: ${target}. Wrap IPv6 addresses in brackets, e.g. "[2001:db8::1]:9473".`);
+        }
+    }
+    if (!hostname) {
+        throw new Error(`Invalid host:port format: ${target}. Host portion is missing.`);
+    }
+    const port = Number.parseInt(portSegment ?? '', 10);
+    if (!Number.isFinite(port) || port <= 0 || port > 65_535) {
+        throw new Error(`Invalid port: "${portSegment ?? ''}". Expected a number between 1 and 65535.`);
+    }
+    return { hostname, port };
+}
+export function parseBridgeConnectionString(input) {
+    const raw = input.trim();
+    if (!raw) {
+        throw new Error('Missing connection string.');
+    }
+    let url;
+    try {
+        url = raw.includes('://') ? new URL(raw) : new URL(`oracle+tcp://${raw}`);
+    }
+    catch (error) {
+        throw new Error(`Invalid connection string: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const hostname = url.hostname?.trim();
+    const port = Number.parseInt(url.port ?? '', 10);
+    if (!hostname || !Number.isFinite(port) || port <= 0 || port > 65_535) {
+        throw new Error(`Invalid connection string host: ${raw}. Expected host:port.`);
+    }
+    const token = url.searchParams.get('token')?.trim() ?? '';
+    if (!token) {
+        throw new Error('Connection string is missing token. Expected "?token=...".');
+    }
+    const remoteHost = normalizeHostPort(hostname, port);
+    return { remoteHost, remoteToken: token };
+}
+export function formatBridgeConnectionString(connection, options = {}) {
+    const { hostname, port } = parseHostPort(connection.remoteHost);
+    const base = `oracle+tcp://${normalizeHostPort(hostname, port)}`;
+    if (!options.includeToken) {
+        return base;
+    }
+    const params = new URLSearchParams({ token: connection.remoteToken });
+    return `${base}?${params.toString()}`;
+}
+export function looksLikePath(value) {
+    return value.includes('/') || value.includes('\\') || value.endsWith('.json');
+}
+export async function readBridgeConnectionArtifact(filePath) {
+    const resolved = path.resolve(process.cwd(), filePath);
+    const raw = await fs.readFile(resolved, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse connection artifact JSON at ${resolved}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error(`Invalid connection artifact at ${resolved}: expected an object.`);
+    }
+    const remoteHost = parsed.remoteHost;
+    const remoteToken = parsed.remoteToken;
+    if (typeof remoteHost !== 'string' || remoteHost.trim().length === 0) {
+        throw new Error(`Invalid connection artifact at ${resolved}: remoteHost is missing.`);
+    }
+    if (typeof remoteToken !== 'string' || remoteToken.trim().length === 0) {
+        throw new Error(`Invalid connection artifact at ${resolved}: remoteToken is missing.`);
+    }
+    // Validate host formatting early so downstream checks don't crash.
+    parseHostPort(remoteHost);
+    return parsed;
+}

package/dist/src/bridge/userConfigFile.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import JSON5 from 'json5';
+export async function readUserConfigFile(configPath) {
+    try {
+        const raw = await fs.readFile(configPath, 'utf8');
+        const parsed = JSON5.parse(raw);
+        return { config: parsed ?? {}, loaded: true };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return { config: {}, loaded: false };
+        }
+        throw new Error(`Failed to read ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function writeUserConfigFile(configPath, config) {
+    const dir = path.dirname(configPath);
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    const contents = `${JSON.stringify(config, null, 2)}\n`;
+    const tempPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(tempPath, contents, { encoding: 'utf8', mode: 0o600 });
+    await fs.rename(tempPath, configPath);
+    if (process.platform !== 'win32') {
+        await fs.chmod(configPath, 0o600).catch(() => undefined);
+    }
+}

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

@@ -27,23 +27,26 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
     const raceReadyEvaluation = evaluationPromise.then((value) => ({ kind: 'evaluation', value }), (error) => {
         throw { source: 'evaluation', error };
     });
-    const pollerPromise = pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex).then((value) => {
-        if (!value) {
-            throw { source: 'poll', error: new Error(ASSISTANT_POLL_TIMEOUT_ERROR) };
-        }
-        return { kind: 'poll', value };
-    }, (error) => {
+    // Use AbortController to stop the poller when the evaluation wins the race,
+    // preventing abandoned polling loops from consuming resources.
+    const pollerAbort = new AbortController();
+    const pollerPromise = pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, pollerAbort.signal).then((value) => ({ kind: 'poll', value }), (error) => {
         throw { source: 'poll', error };
     });
     let evaluation = null;
     try {
         const winner = await Promise.race([raceReadyEvaluation, pollerPromise]);
         if (winner.kind === 'poll') {
+            if (!winner.value) {
+                throw { source: 'poll', error: new Error(ASSISTANT_POLL_TIMEOUT_ERROR) };
+            }
             logger('Captured assistant response via snapshot watchdog');
             evaluationPromise.catch(() => undefined);
             await terminateRuntimeExecution(Runtime);
             return winner.value;
         }
+        // Evaluation won - abort the poller to prevent it from running until timeout
+        pollerAbort.abort();
         evaluation = winner.value;
     }
     catch (wrappedError) {
@@ -86,7 +89,7 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
                     pollerPromise.catch(() => null),
                     delay(remainingMs).then(() => null),
                 ]);
-                if (polled && polled.kind === 'poll') {
+                if (polled && polled.kind === 'poll' && polled.value) {
                     return polled.value;
                 }
             }
@@ -263,12 +266,16 @@ async function terminateRuntimeExecution(Runtime) {
         // ignore termination failures
     }
 }
-async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex) {
+async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, abortSignal) {
     const watchdogDeadline = Date.now() + timeoutMs;
     let previousLength = 0;
     let stableCycles = 0;
     let lastChangeAt = Date.now();
     while (Date.now() < watchdogDeadline) {
+        // Check abort signal to stop polling when another path won the race
+        if (abortSignal?.aborted) {
+            return null;
+        }
         const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex);
         const normalized = normalizeAssistantSnapshot(snapshot);
         if (normalized) {
@@ -286,11 +293,15 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex) {
                 isCompletionVisible(Runtime),
             ]);
             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.
-            const completionStableTarget = shortAnswer ? 12 : currentLength < 40 ? 8 : 4;
-            const requiredStableCycles = shortAnswer ? 12 : 6;
+            // 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 : 1200;
+            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;
@@ -479,33 +490,63 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex) {
       new Promise((resolve, reject) => {
         const deadline = Date.now() + ${timeoutMs};
         let stopInterval = null;
-        const observer = new MutationObserver(() => {
-          const extractedRaw = extractFromTurns();
-          const extractedCandidate =
-            extractedRaw && !isAnswerNowPlaceholder(extractedRaw) ? extractedRaw : null;
-          let extracted = acceptSnapshot(extractedCandidate);
-          if (!extracted) {
-            const fallbackRaw = extractFromMarkdownFallback();
-            const fallbackCandidate =
-              fallbackRaw && !isAnswerNowPlaceholder(fallbackRaw) ? fallbackRaw : null;
-            extracted = acceptSnapshot(fallbackCandidate);
+        let timeoutId = null;
+        let cleanedUp = false;
+        let observer = null;
+
+        // Centralized cleanup to prevent resource leaks
+        const cleanup = () => {
+          if (cleanedUp) return;
+          cleanedUp = true;
+          if (stopInterval) {
+            clearInterval(stopInterval);
+            stopInterval = null;
+          }
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+          }
+          if (observer) {
+            try {
+              observer.disconnect();
+            } catch {
+              // ignore disconnect errors
+            }
+            observer = null;
           }
-          if (extracted) {
-            observer.disconnect();
-            if (stopInterval) {
-              clearInterval(stopInterval);
+        };
+
+        const observerCallback = () => {
+          if (cleanedUp) return;
+          try {
+            const extractedRaw = extractFromTurns();
+            const extractedCandidate =
+              extractedRaw && !isAnswerNowPlaceholder(extractedRaw) ? extractedRaw : null;
+            let extracted = acceptSnapshot(extractedCandidate);
+            if (!extracted) {
+              const fallbackRaw = extractFromMarkdownFallback();
+              const fallbackCandidate =
+                fallbackRaw && !isAnswerNowPlaceholder(fallbackRaw) ? fallbackRaw : null;
+              extracted = acceptSnapshot(fallbackCandidate);
             }
-            resolve(extracted);
-          } else if (Date.now() > deadline) {
-            observer.disconnect();
-            if (stopInterval) {
-              clearInterval(stopInterval);
+            if (extracted) {
+              cleanup();
+              resolve(extracted);
+            } else if (Date.now() > deadline) {
+              cleanup();
+              reject(new Error('Response timeout'));
             }
-            reject(new Error('Response timeout'));
+          } catch (error) {
+            cleanup();
+            reject(error);
           }
-        });
+        };
+
+        observer = new MutationObserver(observerCallback);
         observer.observe(document.body, { childList: true, subtree: true, characterData: true });
+
         stopInterval = setInterval(() => {
+          if (cleanedUp) return;
           const stop = document.querySelector(STOP_SELECTOR);
           if (!stop) {
             return;
@@ -517,11 +558,9 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex) {
           }
           dispatchClickSequence(stop);
         }, 500);
-        setTimeout(() => {
-          if (stopInterval) {
-            clearInterval(stopInterval);
-          }
-          observer.disconnect();
+
+        timeoutId = setTimeout(() => {
+          cleanup();
           reject(new Error('Response timeout'));
         }, ${timeoutMs});
       });
@@ -546,15 +585,19 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex) {
 
     const waitForSettle = async (snapshot) => {
       // Learned: short answers can be 1-2 tokens; enforce longer settle windows to avoid truncation.
+      // 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 settleWindowMs = shortAnswer ? 12_000 : 5_000;
+      const mediumAnswer = initialLength >= 16 && initialLength < 40;
+      const longAnswer = initialLength >= 40 && initialLength < 500;
+      const settleWindowMs = shortAnswer ? 12_000 : mediumAnswer ? 5_000 : longAnswer ? 8_000 : 10_000;
       const settleIntervalMs = 400;
       const deadline = Date.now() + settleWindowMs;
       let latest = snapshot;
       let lastLength = snapshot?.text?.length ?? 0;
       let stableCycles = 0;
-      const stableTarget = shortAnswer ? 6 : 3;
+      const stableTarget = shortAnswer ? 6 : mediumAnswer ? 3 : longAnswer ? 5 : 6;
       while (Date.now() < deadline) {
         await new Promise((resolve) => setTimeout(resolve, settleIntervalMs));
         const refreshedRaw = extractFromTurns();
@@ -678,7 +721,7 @@ function buildAssistantExtractor(functionName) {
 function buildMarkdownFallbackExtractor(minTurnLiteral) {
     const turnIndexValue = minTurnLiteral ? `(${minTurnLiteral} >= 0 ? ${minTurnLiteral} : null)` : 'null';
     return `(() => {
-    const MIN_TURN_INDEX = ${turnIndexValue};
+    const __minTurn = ${turnIndexValue};
     const roots = [
       document.querySelector('section[data-testid="screen-threadFlyOut"]'),
       document.querySelector('[data-testid="chat-thread"]'),
@@ -720,10 +763,10 @@ function buildMarkdownFallbackExtractor(minTurnLiteral) {
       return idx >= 0 ? idx : null;
     };
     const isAfterMinTurn = (node) => {
-      if (MIN_TURN_INDEX === null) return true;
+      if (__minTurn === null) return true;
       if (!hasTurns) return true;
       const idx = resolveTurnIndex(node);
-      return idx !== null && idx >= MIN_TURN_INDEX;
+      return idx !== null && idx >= __minTurn;
     };
     const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
     const collectUserText = (scope) => {

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

@@ -18,6 +18,13 @@ export async function submitPrompt(deps, prompt, logger) {
         expression: `(() => {
       ${buildClickDispatcher()}
       const SELECTORS = ${JSON.stringify(INPUT_SELECTORS)};
+      const isVisible = (node) => {
+        if (!node || typeof node.getBoundingClientRect !== 'function') {
+          return false;
+        }
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
       const focusNode = (node) => {
         if (!node) {
           return false;
@@ -39,13 +46,17 @@ export async function submitPrompt(deps, prompt, logger) {
         return true;
       };
 
+      const candidates = [];
       for (const selector of SELECTORS) {
         const node = document.querySelector(selector);
-        if (!node) continue;
-        if (focusNode(node)) {
-          return { focused: true };
+        if (node) {
+          candidates.push(node);
         }
       }
+      const preferred = candidates.find((node) => isVisible(node)) || candidates[0];
+      if (preferred && focusNode(preferred)) {
+        return { focused: true };
+      }
       return { focused: false };
     })()`,
         returnByValue: true,
@@ -65,18 +76,36 @@ export async function submitPrompt(deps, prompt, logger) {
         expression: `(() => {
       const editor = document.querySelector(${primarySelectorLiteral});
       const fallback = document.querySelector(${fallbackSelectorLiteral});
+      const inputSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+      const readValue = (node) => {
+        if (!node) return '';
+        if (node instanceof HTMLTextAreaElement) return node.value ?? '';
+        return node.innerText ?? '';
+      };
+      const isVisible = (node) => {
+        if (!node || typeof node.getBoundingClientRect !== 'function') return false;
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+      const candidates = inputSelectors
+        .map((selector) => document.querySelector(selector))
+        .filter((node) => Boolean(node));
+      const active = candidates.find((node) => isVisible(node)) || candidates[0] || null;
       return {
         editorText: editor?.innerText ?? '',
         fallbackValue: fallback?.value ?? '',
+        activeValue: active ? readValue(active) : '',
       };
     })()`,
         returnByValue: true,
     });
     const editorTextRaw = verification.result?.value?.editorText ?? '';
     const fallbackValueRaw = verification.result?.value?.fallbackValue ?? '';
+    const activeValueRaw = verification.result?.value?.activeValue ?? '';
     const editorTextTrimmed = editorTextRaw?.trim?.() ?? '';
     const fallbackValueTrimmed = fallbackValueRaw?.trim?.() ?? '';
-    if (!editorTextTrimmed && !fallbackValueTrimmed) {
+    const activeValueTrimmed = activeValueRaw?.trim?.() ?? '';
+    if (!editorTextTrimmed && !fallbackValueTrimmed && !activeValueTrimmed) {
         // Learned: occasionally Input.insertText doesn't land in the editor; force textContent/value + input events.
         await runtime.evaluate({
             expression: `(() => {
@@ -100,16 +129,33 @@ export async function submitPrompt(deps, prompt, logger) {
         expression: `(() => {
       const editor = document.querySelector(${primarySelectorLiteral});
       const fallback = document.querySelector(${fallbackSelectorLiteral});
+      const inputSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+      const readValue = (node) => {
+        if (!node) return '';
+        if (node instanceof HTMLTextAreaElement) return node.value ?? '';
+        return node.innerText ?? '';
+      };
+      const isVisible = (node) => {
+        if (!node || typeof node.getBoundingClientRect !== 'function') return false;
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+      const candidates = inputSelectors
+        .map((selector) => document.querySelector(selector))
+        .filter((node) => Boolean(node));
+      const active = candidates.find((node) => isVisible(node)) || candidates[0] || null;
       return {
         editorText: editor?.innerText ?? '',
         fallbackValue: fallback?.value ?? '',
+        activeValue: active ? readValue(active) : '',
       };
     })()`,
         returnByValue: true,
     });
     const observedEditor = postVerification.result?.value?.editorText ?? '';
     const observedFallback = postVerification.result?.value?.fallbackValue ?? '';
-    const observedLength = Math.max(observedEditor.length, observedFallback.length);
+    const observedActive = postVerification.result?.value?.activeValue ?? '';
+    const observedLength = Math.max(observedEditor.length, observedFallback.length, observedActive.length);
     if (promptLength >= 50_000 && observedLength > 0 && observedLength < promptLength - 2_000) {
         // Learned: very large prompts can truncate silently; fail fast so we can fall back to file uploads.
         await logDomFailure(runtime, logger, 'prompt-too-large');
@@ -144,10 +190,12 @@ export async function submitPrompt(deps, prompt, logger) {
 export async function clearPromptComposer(Runtime, logger) {
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const inputSelectorsLiteral = JSON.stringify(INPUT_SELECTORS);
     const result = await Runtime.evaluate({
         expression: `(() => {
       const fallback = document.querySelector(${fallbackSelectorLiteral});
       const editor = document.querySelector(${primarySelectorLiteral});
+      const inputSelectors = ${inputSelectorsLiteral};
       let cleared = false;
       if (fallback) {
         fallback.value = '';
@@ -160,6 +208,24 @@ export async function clearPromptComposer(Runtime, logger) {
         editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
         cleared = true;
       }
+      const nodes = inputSelectors
+        .map((selector) => document.querySelector(selector))
+        .filter((node) => Boolean(node));
+      for (const node of nodes) {
+        if (!node) continue;
+        if (node instanceof HTMLTextAreaElement) {
+          node.value = '';
+          node.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
+          node.dispatchEvent(new Event('change', { bubbles: true }));
+          cleared = true;
+          continue;
+        }
+        if (node.isContentEditable || node.getAttribute('contenteditable') === 'true') {
+          node.textContent = '';
+          node.dispatchEvent(new InputEvent('input', { bubbles: true, data: '', inputType: 'deleteByCut' }));
+          cleared = true;
+        }
+      }
       return { cleared };
     })()`,
         returnByValue: true,
@@ -281,15 +347,34 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
     const encodedPrompt = JSON.stringify(prompt.trim());
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
+    const inputSelectorsLiteral = JSON.stringify(INPUT_SELECTORS);
     const stopSelectorLiteral = JSON.stringify(STOP_BUTTON_SELECTOR);
     const assistantSelectorLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
-    const baselineLiteral = typeof baselineTurns === 'number' && Number.isFinite(baselineTurns) && baselineTurns >= 0
+    const turnSelectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    let baseline = typeof baselineTurns === 'number' && Number.isFinite(baselineTurns) && baselineTurns >= 0
         ? Math.floor(baselineTurns)
-        : -1;
+        : null;
+    if (baseline === null) {
+        try {
+            const { result } = await Runtime.evaluate({
+                expression: `document.querySelectorAll(${turnSelectorLiteral}).length`,
+                returnByValue: true,
+            });
+            const raw = typeof result?.value === 'number' ? result.value : Number(result?.value);
+            if (Number.isFinite(raw)) {
+                baseline = Math.max(0, Math.floor(raw));
+            }
+        }
+        catch {
+            // ignore; baseline stays unknown
+        }
+    }
+    const baselineLiteral = baseline ?? -1;
     // Learned: ChatGPT can echo/format text; normalize markdown and use prefix matches to detect the sent prompt.
     const script = `(() => {
-	    const editor = document.querySelector(${primarySelectorLiteral});
-	    const fallback = document.querySelector(${fallbackSelectorLiteral});
+		    const editor = document.querySelector(${primarySelectorLiteral});
+		    const fallback = document.querySelector(${fallbackSelectorLiteral});
+		    const inputSelectors = ${inputSelectorsLiteral};
 	    const normalize = (value) => {
 	      let text = value?.toLowerCase?.() ?? '';
 	      // Strip markdown *markers* but keep content (ChatGPT renders fence markers differently).
@@ -303,35 +388,53 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
 	    const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
 	    const articles = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
 	    const normalizedTurns = articles.map((node) => normalize(node?.innerText));
+	    const readValue = (node) => {
+	      if (!node) return '';
+	      if (node instanceof HTMLTextAreaElement) return node.value ?? '';
+	      return node.innerText ?? '';
+	    };
+	    const isVisible = (node) => {
+	      if (!node || typeof node.getBoundingClientRect !== 'function') return false;
+	      const rect = node.getBoundingClientRect();
+	      return rect.width > 0 && rect.height > 0;
+	    };
+	    const inputs = inputSelectors
+	      .map((selector) => document.querySelector(selector))
+	      .filter((node) => Boolean(node));
+	    const visibleInputs = inputs.filter((node) => isVisible(node));
+	    const activeInputs = visibleInputs.length > 0 ? visibleInputs : inputs;
 	    const userMatched =
 	      normalizedPrompt.length > 0 && normalizedTurns.some((text) => text.includes(normalizedPrompt));
 	    const prefixMatched =
 	      normalizedPromptPrefix.length > 30 &&
 	      normalizedTurns.some((text) => text.includes(normalizedPromptPrefix));
-	    const lastTurn = normalizedTurns[normalizedTurns.length - 1] ?? '';
-	    const lastMatched =
-	      normalizedPrompt.length > 0 &&
-	      (lastTurn.includes(normalizedPrompt) ||
-	        (normalizedPromptPrefix.length > 30 && lastTurn.includes(normalizedPromptPrefix)));
-	    const baseline = ${baselineLiteral};
-	    const hasNewTurn = baseline < 0 ? true : normalizedTurns.length > baseline;
-      const stopVisible = Boolean(document.querySelector(${stopSelectorLiteral}));
-      const assistantVisible = Boolean(
-        document.querySelector(${assistantSelectorLiteral}) ||
-        document.querySelector('[data-testid*="assistant"]'),
-      );
-      // Learned: composer clearing + stop button or assistant presence is a reliable fallback signal.
+		    const lastTurn = normalizedTurns[normalizedTurns.length - 1] ?? '';
+		    const lastMatched =
+		      normalizedPrompt.length > 0 &&
+		      (lastTurn.includes(normalizedPrompt) ||
+		        (normalizedPromptPrefix.length > 30 && lastTurn.includes(normalizedPromptPrefix)));
+		    const baseline = ${baselineLiteral};
+		    const hasNewTurn = baseline < 0 ? false : normalizedTurns.length > baseline;
+		    const stopVisible = Boolean(document.querySelector(${stopSelectorLiteral}));
+		    const assistantVisible = Boolean(
+		      document.querySelector(${assistantSelectorLiteral}) ||
+		      document.querySelector('[data-testid*="assistant"]'),
+		    );
+	    // Learned: composer clearing + stop button or assistant presence is a reliable fallback signal.
       const editorValue = editor?.innerText ?? '';
       const fallbackValue = fallback?.value ?? '';
-      const composerCleared = !(String(editorValue).trim() || String(fallbackValue).trim());
+      const activeEmpty =
+        activeInputs.length === 0 ? null : activeInputs.every((node) => !String(readValue(node)).trim());
+      const composerCleared = activeEmpty ?? !(String(editorValue).trim() || String(fallbackValue).trim());
       const href = typeof location === 'object' && location.href ? location.href : '';
       const inConversation = /\\/c\\//.test(href);
-	    return {
-      userMatched,
-      prefixMatched,
-      lastMatched,
-      hasNewTurn,
-      stopVisible,
+		    return {
+        baseline,
+	      userMatched,
+	      prefixMatched,
+	      lastMatched,
+	      hasNewTurn,
+	      stopVisible,
       assistantVisible,
       composerCleared,
       inConversation,
@@ -346,12 +449,14 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
         const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
         const info = result.value;
         const turnsCount = result.value?.turnsCount;
-        if (info?.hasNewTurn && (info?.lastMatched || info?.userMatched || info?.prefixMatched)) {
+        const matchesPrompt = Boolean(info?.lastMatched || info?.userMatched || info?.prefixMatched);
+        const baselineUnknown = typeof info?.baseline === 'number' ? info.baseline < 0 : baselineLiteral < 0;
+        if (matchesPrompt && (baselineUnknown || info?.hasNewTurn)) {
             return typeof turnsCount === 'number' && Number.isFinite(turnsCount) ? turnsCount : null;
         }
         const fallbackCommit = info?.composerCleared &&
-            ((info?.stopVisible ?? false) ||
-                (info?.hasNewTurn && (info?.assistantVisible || info?.inConversation)));
+            Boolean(info?.hasNewTurn) &&
+            ((info?.stopVisible ?? false) || info?.assistantVisible || info?.inConversation);
         if (fallbackCommit) {
             return typeof turnsCount === 'number' && Number.isFinite(turnsCount) ? turnsCount : null;
         }
@@ -374,3 +479,7 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
     }
     throw new Error('Prompt did not appear in conversation before timeout (send may have failed)');
 }
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    verifyPromptCommitted,
+};