cueline 0.1.2 → 0.1.4

package/dist/src/browser/codex-iab/chatgpt-client.js

@@ -1,6 +1,8 @@
 import { CueLineError } from "../../core/errors.js";
-import { readPageChatState, resolveIabBrowser, } from "./bootstrap.js";
+import { readPageChatState, readPageComposerState, resolveIabBrowser, } from "./bootstrap.js";
 import { CHATGPT_URL, COMPOSER_TEXTBOX_NAMES, SEND_BUTTON_NAMES } from "./selectors.js";
+import { hasExactControllerEnvelopeIdentity, isProLabel, isProModelSlug, normalizedConversationUrl, normalizedMessageText } from "./recovery-evidence.js";
+import { captureConversationUrlAfterSubmit } from "./submission-url.js";
 const DEFAULT_TIMEOUT_MS = 30 * 60 * 1_000;
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
 const DEFAULT_STABLE_MS = 1_500;
@@ -10,8 +12,36 @@ const MODEL_PICKER_SELECTOR = "button.__composer-pill";
 const REQUIRED_MODEL_LABEL = "Pro";
 const MODEL_LABEL_READ_ATTEMPTS = 50;
 const MODEL_LABEL_RETRY_INTERVAL_MS = 100;
-function delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+const TAB_DISCOVERY_RETRY_MS = 100;
+const COMPOSER_READY_TIMEOUT_MS = 30_000;
+const COMPOSER_READY_STABLE_MS = 250;
+function throwIfCancelled(signal) {
+    if (signal?.aborted !== true)
+        return;
+    if (signal.reason instanceof CueLineError)
+        throw signal.reason;
+    throw new CueLineError("RUN_CANCELLED", "CueLine run cancellation was requested.", {
+        cause: signal.reason,
+    });
+}
+function delay(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        throwIfCancelled(signal);
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, milliseconds);
+        const onAbort = () => {
+            clearTimeout(timer);
+            try {
+                throwIfCancelled(signal);
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
 }
 async function findUniqueLocator(tab, role, names) {
     for (const name of names) {
@@ -22,6 +52,45 @@ async function findUniqueLocator(tab, role, names) {
     }
     return undefined;
 }
+async function findVisibleSendButtonCoordinates(tab) {
+    if (!tab.cua?.click)
+        return undefined;
+    const target = await tab.playwright.evaluate(({ sendButtonNames }) => {
+        const normalize = (value) => String(value ?? "").trim().replace(/\s+/g, " ");
+        const candidates = Array.from(document.querySelectorAll("button")).filter((element) => {
+            const button = element;
+            const style = window.getComputedStyle(button);
+            const rect = button.getBoundingClientRect();
+            const label = normalize(button.getAttribute("aria-label") ?? button.innerText ?? button.textContent);
+            return (sendButtonNames.some((name) => name === label) &&
+                !button.disabled &&
+                button.getAttribute("aria-disabled") !== "true" &&
+                style.display !== "none" &&
+                style.visibility !== "hidden" &&
+                rect.width > 0 &&
+                rect.height > 0 &&
+                rect.right > 0 &&
+                rect.bottom > 0 &&
+                rect.left < window.innerWidth &&
+                rect.top < window.innerHeight);
+        });
+        if (candidates.length !== 1)
+            return null;
+        const rect = candidates[0].getBoundingClientRect();
+        return {
+            x: rect.left + rect.width / 2,
+            y: rect.top + rect.height / 2,
+        };
+    }, { sendButtonNames: [...SEND_BUTTON_NAMES] }).catch(() => null);
+    if (target === null ||
+        !Number.isFinite(target.x) ||
+        !Number.isFinite(target.y) ||
+        target.x < 0 ||
+        target.y < 0) {
+        return undefined;
+    }
+    return { x: Math.round(target.x), y: Math.round(target.y) };
+}
 async function findHydratedComposer(tab) {
     if (!tab.playwright.locator)
         return undefined;
@@ -37,31 +106,12 @@ async function findHydratedComposer(tab) {
 function isConversationUrl(url) {
     return /^https:\/\/chatgpt\.com\/c\/[A-Za-z0-9-]+/.test(url);
 }
-function isTransientClickError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /deadline exceeded|timed? out|timeout|detached|stale|not enabled|not visible/i.test(message);
-}
 function isTabUnavailableError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /tab not found|existing tabs: none|webview attach|cdp operation exceeded|target closed|page closed|browser.*disconnected/i.test(message);
 }
-function normalizedConversationUrl(url) {
-    try {
-        const parsed = new URL(url);
-        return `${parsed.origin}${parsed.pathname}`;
-    }
-    catch {
-        return url;
-    }
-}
-function isProLabel(label) {
-    return /^Pro(?:\s+(?:Standard|Extended))?$/i.test(label ?? "");
-}
-function isProModelSlug(slug) {
-    return /(?:^|-)pro(?:-|$)/i.test(slug ?? "");
-}
-function normalizedMessageText(value) {
-    return (value ?? "").replace(/\r\n/g, "\n").trim();
+function ambiguousSubmissionError(error) {
+    return new CueLineError("CONTROLLER_SUBMISSION_AMBIGUOUS", "The send-button click failed without proving whether ChatGPT accepted the prompt. Refusing a second click; reconcile the exact conversation instead.", { cause: error });
 }
 function submissionStateForStage(stage) {
     if (stage === "pre_submit")
@@ -89,8 +139,9 @@ async function readComposerModelLabel(tab) {
         return labels.length === 1 ? labels[0] : null;
     }, { modelPickerSelector: MODEL_PICKER_SELECTOR });
 }
-async function readComposerModelLabelWhenReady(tab) {
+async function readComposerModelLabelWhenReady(tab, signal) {
     for (let attempt = 0; attempt < MODEL_LABEL_READ_ATTEMPTS; attempt += 1) {
+        throwIfCancelled(signal);
         const label = await readComposerModelLabel(tab);
         if (label !== null)
             return label;
@@ -141,34 +192,42 @@ class CodexIabAdapter {
         const matchesTarget = (url) => targetUrl
             ? normalizedConversationUrl(url) === normalizedConversationUrl(targetUrl)
             : url.startsWith(CHATGPT_URL);
-        const selected = await browser.tabs.selected?.().catch(() => undefined);
-        if (selected && matchesTarget((await selected.url().catch(() => "")) ?? "")) {
-            this.#tab = selected;
-            return selected;
-        }
-        const sessionTabs = await browser.tabs.list?.().catch(() => []);
-        const sessionCandidate = sessionTabs?.find((tab) => matchesTarget(String(tab.url ?? "")));
         let tab;
-        if (sessionCandidate?.id && browser.tabs.get) {
-            tab = await browser.tabs.get(sessionCandidate.id);
-        }
-        const openTabs = tab === undefined ? await browser.user?.openTabs?.().catch(() => []) : [];
-        const candidate = openTabs?.find((openTab) => {
-            const url = String(openTab.url ?? "");
-            return matchesTarget(url);
-        });
-        if (tab === undefined && candidate && browser.user?.claimTab) {
-            tab = await browser.user.claimTab(candidate);
+        const canDiscover = browser.tabs.selected !== undefined ||
+            browser.tabs.list !== undefined ||
+            browser.user?.openTabs !== undefined;
+        const discoveryPasses = canDiscover ? 2 : 1;
+        for (let pass = 0; pass < discoveryPasses && tab === undefined; pass += 1) {
+            const selected = await browser.tabs.selected?.();
+            if (selected && matchesTarget((await selected.url()) ?? "")) {
+                tab = selected;
+                break;
+            }
+            const sessionTabs = (await browser.tabs.list?.()) ?? [];
+            const sessionCandidate = sessionTabs.find((candidate) => matchesTarget(String(candidate.url ?? "")));
+            if (sessionCandidate?.id && browser.tabs.get) {
+                tab = await browser.tabs.get(sessionCandidate.id);
+            }
+            if (tab === undefined) {
+                const openTabs = (await browser.user?.openTabs?.()) ?? [];
+                const candidate = openTabs.find((openTab) => matchesTarget(String(openTab.url ?? "")));
+                if (candidate && browser.user?.claimTab) {
+                    tab = await browser.user.claimTab(candidate);
+                }
+            }
+            if (tab === undefined && pass < discoveryPasses - 1) {
+                await delay(TAB_DISCOVERY_RETRY_MS);
+            }
         }
-        else if (tab === undefined) {
+        if (tab === undefined) {
             tab = await browser.tabs.new();
             await tab.goto(targetUrl ?? CHATGPT_URL);
         }
-        this.#tab = tab;
         await tab.playwright.waitForLoadState?.({
             state: "domcontentloaded",
             timeoutMs: 30_000,
         });
+        this.#tab = tab;
         return tab;
     }
     async #ensureProModel(tab) {
@@ -204,6 +263,7 @@ class CodexIabAdapter {
             return true;
         }
         return (await readPageChatState(tab).catch(() => ({
+            pageUrl: "",
             isAnswering: false,
             assistantText: "",
             assistantMessageCount: 0,
@@ -212,38 +272,41 @@ class CodexIabAdapter {
             lastMessageRole: null,
         }))).isAnswering;
     }
-    async #clickSend(tab) {
+    async #resolveSendTarget(tab) {
+        const locator = await findUniqueLocator(tab, "button", SEND_BUTTON_NAMES);
+        if (locator)
+            return { kind: "locator", locator };
+        const coordinate = await findVisibleSendButtonCoordinates(tab);
+        if (coordinate)
+            return { kind: "coordinate", ...coordinate };
+        throw new CueLineError("SEND_BUTTON_MISSING", "Could not find ChatGPT's send button.");
+    }
+    async #clickSend(tab, target) {
         const previousUrl = (await tab.url()) ?? "";
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            const button = await findUniqueLocator(tab, "button", SEND_BUTTON_NAMES);
-            if (!button) {
-                if (attempt > 0 && await this.#submissionStarted(tab, previousUrl)) {
-                    return;
-                }
-                throw new CueLineError("SEND_BUTTON_MISSING", "Could not find ChatGPT's send button.");
-            }
-            try {
-                await button.click({ timeoutMs: 10_000 });
-                return;
+        try {
+            if (target.kind === "locator") {
+                await target.locator.click({ timeoutMs: 10_000 });
             }
-            catch (error) {
-                if (await this.#submissionStarted(tab, previousUrl)) {
-                    return;
-                }
-                if (attempt === 1 || !isTransientClickError(error)) {
-                    throw error;
-                }
-                await tab.playwright.domSnapshot();
-                await tab.playwright.waitForTimeout(250);
+            else {
+                await tab.cua.click({ x: target.x, y: target.y });
+                await tab.playwright.waitForTimeout(100);
             }
         }
+        catch (error) {
+            if (await this.#submissionStarted(tab, previousUrl))
+                return;
+            if (isTabUnavailableError(error))
+                throw error;
+            throw ambiguousSubmissionError(error);
+        }
     }
-    async #waitForCompletion(tab, baseline) {
+    async #waitForCompletion(tab, baseline, signal) {
         const deadline = Date.now() + this.#options.timeoutMs;
         let stableText = "";
         let stableSince = 0;
         let responseStarted = false;
         while (Date.now() < deadline) {
+            throwIfCancelled(signal);
             const state = await readPageChatState(tab);
             if (state.isAnswering || state.assistantMessageCount > baseline.assistantMessageCount) {
                 responseStarted = true;
@@ -261,22 +324,26 @@ class CodexIabAdapter {
                 stableText = state.assistantText;
                 stableSince = Date.now();
             }
-            await delay(this.#options.pollIntervalMs);
+            await delay(this.#options.pollIntervalMs, signal);
         }
         throw new CueLineError("CHATGPT_RESPONSE_TIMEOUT", "ChatGPT did not finish before timeout.");
     }
-    async #waitForRecoveredCompletion(tab, expectedPrompt) {
+    async #waitForRecoveredCompletion(tab, expectedPrompt, allowVisiblePromptMismatch, manualSendConfirmed, baselineAssistantMessageCount, expectedConversationUrl, expectedIdentity, signal) {
+        const attachmentBaseline = allowVisiblePromptMismatch
+            ? baselineAssistantMessageCount
+            : undefined;
+        if (allowVisiblePromptMismatch &&
+            attachmentBaseline === undefined &&
+            !manualSendConfirmed) {
+            throw new CueLineError("CONTROLLER_RECONCILIATION_BASELINE_REQUIRED", "Attachment recovery requires the durable pre-submit assistant message count; refusing to import a possibly stale response.");
+        }
         const deadline = Date.now() + this.#options.timeoutMs;
         let stableText = "";
         let stableSince = 0;
         while (Date.now() < deadline) {
-            const state = await readPageChatState(tab);
-            if (normalizedMessageText(state.lastUserText) !== normalizedMessageText(expectedPrompt)) {
-                throw new CueLineError("CONTROLLER_RECONCILIATION_MISMATCH", "The exact conversation's last user message does not match the pending CueLine prompt. Refusing to import an unrelated response.");
-            }
-            if (!state.isAnswering &&
-                state.lastMessageRole === "assistant" &&
-                state.assistantText !== "") {
+            throwIfCancelled(signal);
+            const state = await this.#readRecoveredCandidate(tab, expectedPrompt, allowVisiblePromptMismatch, manualSendConfirmed, attachmentBaseline, expectedConversationUrl, expectedIdentity);
+            if (state !== undefined) {
                 if (state.assistantText !== stableText) {
                     stableText = state.assistantText;
                     stableSince = Date.now();
@@ -288,10 +355,87 @@ class CodexIabAdapter {
                 stableText = "";
                 stableSince = Date.now();
             }
-            await delay(this.#options.pollIntervalMs);
+            await delay(this.#options.pollIntervalMs, signal);
         }
         throw new CueLineError("CONTROLLER_RECONCILIATION_TIMEOUT", "The existing ChatGPT response did not become readable before timeout; no prompt was sent.");
     }
+    async #readRecoveredCandidate(tab, expectedPrompt, allowVisiblePromptMismatch, manualSendConfirmed, attachmentBaseline, expectedConversationUrl, expectedIdentity) {
+        const state = await readPageChatState(tab);
+        if (normalizedConversationUrl(state.pageUrl) !==
+            normalizedConversationUrl(expectedConversationUrl)) {
+            throw new CueLineError("CONTROLLER_RECONCILIATION_CONVERSATION_MISMATCH", "The response evidence was read from a different ChatGPT conversation DOM.");
+        }
+        if (attachmentBaseline !== undefined &&
+            state.assistantMessageCount <= attachmentBaseline)
+            return undefined;
+        if (manualSendConfirmed &&
+            attachmentBaseline === undefined &&
+            !hasExactControllerEnvelopeIdentity(state.assistantText, expectedIdentity))
+            return undefined;
+        if (state.lastUserText === null && !manualSendConfirmed)
+            return undefined;
+        if (!allowVisiblePromptMismatch &&
+            normalizedMessageText(state.lastUserText) !== normalizedMessageText(expectedPrompt)) {
+            throw new CueLineError("CONTROLLER_RECONCILIATION_MISMATCH", "The exact conversation's last user message does not match the pending CueLine prompt. Refusing to import an unrelated response.");
+        }
+        return !state.isAnswering &&
+            state.lastMessageRole === "assistant" &&
+            state.assistantText !== ""
+            ? state
+            : undefined;
+    }
+    async #observeRecoveredCompletion(tab, expectedPrompt, allowVisiblePromptMismatch, manualSendConfirmed, baselineAssistantMessageCount, expectedConversationUrl, expectedIdentity, signal) {
+        if (allowVisiblePromptMismatch &&
+            baselineAssistantMessageCount === undefined &&
+            !manualSendConfirmed) {
+            throw new CueLineError("CONTROLLER_RECONCILIATION_BASELINE_REQUIRED", "Attachment recovery requires the durable pre-submit assistant message count; refusing to import a possibly stale response.");
+        }
+        throwIfCancelled(signal);
+        const first = await this.#readRecoveredCandidate(tab, expectedPrompt, allowVisiblePromptMismatch, manualSendConfirmed, allowVisiblePromptMismatch ? baselineAssistantMessageCount : undefined, expectedConversationUrl, expectedIdentity);
+        if (first === undefined)
+            return undefined;
+        if (this.#options.stableMs > 0)
+            await delay(this.#options.stableMs, signal);
+        const second = await this.#readRecoveredCandidate(tab, expectedPrompt, allowVisiblePromptMismatch, manualSendConfirmed, allowVisiblePromptMismatch ? baselineAssistantMessageCount : undefined, expectedConversationUrl, expectedIdentity);
+        return second !== undefined &&
+            second.assistantText === first.assistantText &&
+            second.assistantMessageCount === first.assistantMessageCount &&
+            second.assistantModelSlug === first.assistantModelSlug
+            ? second
+            : undefined;
+    }
+    async #waitForComposerReady(tab, expectedPrompt, baselineAttachmentCount, signal) {
+        const deadline = Date.now() + Math.min(COMPOSER_READY_TIMEOUT_MS, this.#options.timeoutMs);
+        const stableRequirement = Math.min(COMPOSER_READY_STABLE_MS, this.#options.stableMs);
+        let stableSignature = "";
+        let stableSince = 0;
+        let lastState = await readPageComposerState(tab, expectedPrompt, SEND_BUTTON_NAMES);
+        while (Date.now() < deadline) {
+            throwIfCancelled(signal);
+            const state = await readPageComposerState(tab, expectedPrompt, SEND_BUTTON_NAMES);
+            lastState = state;
+            const ready = state.sendButtonEnabled &&
+                (state.state === "inline_ready" ||
+                    (state.state === "attachment_ready" &&
+                        state.attachmentCount > baselineAttachmentCount));
+            const signature = `${state.state}:${state.inlineTextLength}:${state.attachmentCount}:${state.sendButtonEnabled}`;
+            if (ready) {
+                if (signature !== stableSignature) {
+                    stableSignature = signature;
+                    stableSince = Date.now();
+                }
+                if (Date.now() - stableSince >= stableRequirement && ready) {
+                    return state.state === "inline_ready" ? "inline_ready" : "attachment_ready";
+                }
+            }
+            else {
+                stableSignature = "";
+                stableSince = 0;
+            }
+            await delay(Math.min(this.#options.pollIntervalMs, 100), signal);
+        }
+        throw new CueLineError("CONTROLLER_PROMPT_NOT_READY", "ChatGPT exposed neither the exact inline prompt nor an attachment with an enabled send button after the composer settled.", { details: { composer_state: lastState.state, attachment_count: lastState.attachmentCount } });
+    }
     async #resultFromCompletedTurn(tab, selectedModelLabel, completed) {
         if (!isProModelSlug(completed.assistantModelSlug)) {
             throw new CueLineError("PRO_MODEL_MISMATCH", `ChatGPT returned model '${completed.assistantModelSlug ?? "unknown"}' after Pro was selected. Refusing the controller response.`, {
@@ -301,7 +445,10 @@ class CodexIabAdapter {
                 },
             });
         }
-        const conversationUrl = (await tab.url()) ?? "";
+        // Bind response text and URL from one DOM evaluation. A later CDP URL
+        // read can observe navigation to another conversation and must never be
+        // paired with this completed assistant message.
+        const conversationUrl = completed.pageUrl;
         if (isConversationUrl(conversationUrl))
             this.#conversationUrl = conversationUrl;
         const title = await tab.title?.();
@@ -318,8 +465,10 @@ class CodexIabAdapter {
             ...(title === undefined || title === "" ? {} : { title }),
         };
     }
-    async #sendTurnOnce(input, context, hooks) {
+    async #submitTurnOnce(input, context, hooks, requireRecoverableCheckpoint = false) {
+        throwIfCancelled(input.signal);
         const tab = await this.#getTab();
+        throwIfCancelled(input.signal);
         const composer = (await findHydratedComposer(tab)) ??
             (await findUniqueLocator(tab, "textbox", COMPOSER_TEXTBOX_NAMES));
         if (!composer) {
@@ -327,24 +476,48 @@ class CodexIabAdapter {
         }
         context.selectedModelLabel = await this.#ensureProModel(tab);
         context.baseline = await readPageChatState(tab);
+        const composerBaseline = await readPageComposerState(tab, input.prompt, SEND_BUTTON_NAMES);
+        if (composerBaseline.attachmentCount > 0) {
+            throw new CueLineError("CONTROLLER_PROMPT_NOT_READY", "The ChatGPT composer already contains an attachment. Refusing to mix it with the current controller prompt.", {
+                details: {
+                    composer_state: composerBaseline.state,
+                    attachment_count: composerBaseline.attachmentCount,
+                },
+            });
+        }
         await composer.fill(input.prompt, {});
-        await this.#emitCheckpoint(tab, context, hooks, "possibly_sent");
+        throwIfCancelled(input.signal);
+        context.composerPromptState = await this.#waitForComposerReady(tab, input.prompt, composerBaseline.attachmentCount, input.signal);
+        const sendTarget = await this.#resolveSendTarget(tab);
+        await this.#emitCheckpoint(tab, context, hooks, "submitting");
         context.stage = "submitting";
-        await this.#clickSend(tab);
+        await this.#clickSend(tab, sendTarget);
+        if (requireRecoverableCheckpoint) {
+            this.#conversationUrl = await captureConversationUrlAfterSubmit(tab, this.#conversationUrl, this.#options.timeoutMs, this.#options.pollIntervalMs, input.signal);
+        }
         context.stage = "submitted";
-        await this.#emitCheckpoint(tab, context, hooks, "submitted");
-        const completed = await this.#waitForCompletion(tab, context.baseline);
+        await this.#emitCheckpoint(tab, context, hooks, "submitted", requireRecoverableCheckpoint ? this.#conversationUrl : undefined);
+        return tab;
+    }
+    async #sendTurnOnce(input, context, hooks) {
+        const tab = await this.#submitTurnOnce(input, context, hooks);
+        const completed = await this.#waitForCompletion(tab, context.baseline, input.signal);
         return this.#resultFromCompletedTurn(tab, context.selectedModelLabel, completed);
     }
-    async #emitCheckpoint(tab, context, hooks, submissionState) {
-        if (!context.baseline || !context.selectedModelLabel)
+    async #emitCheckpoint(tab, context, hooks, submissionState, capturedConversationUrl) {
+        if (!context.baseline || !context.selectedModelLabel || !context.composerPromptState)
             return;
-        const currentUrl = (await tab.url().catch(() => "")) ?? "";
-        if (isConversationUrl(currentUrl))
-            this.#conversationUrl = currentUrl;
+        const currentUrl = capturedConversationUrl ?? (await tab.url().catch(() => "")) ?? "";
+        const checkpointUrl = isConversationUrl(currentUrl) ? currentUrl : this.#conversationUrl;
+        if (checkpointUrl !== undefined && isConversationUrl(checkpointUrl)) {
+            this.#conversationUrl = checkpointUrl;
+        }
         await hooks?.onCheckpoint?.({
             submissionState,
-            ...(isConversationUrl(currentUrl) ? { conversationUrl: currentUrl } : {}),
+            composerPromptState: context.composerPromptState,
+            ...(checkpointUrl !== undefined && isConversationUrl(checkpointUrl)
+                ? { conversationUrl: checkpointUrl }
+                : {}),
             selectedModelLabel: context.selectedModelLabel,
             baselineAssistantMessageCount: context.baseline.assistantMessageCount,
         });
@@ -380,6 +553,13 @@ class CodexIabAdapter {
         catch (error) {
             if (!isTabUnavailableError(error))
                 throw this.#browserFailure(error, context, input);
+            this.#tab = undefined;
+            if (context.stage === "pre_submit") {
+                const retryContext = { stage: "pre_submit" };
+                return this.#sendTurnOnce(input, retryContext, hooks).catch((retryError) => {
+                    throw this.#browserFailure(retryError, retryContext, input);
+                });
+            }
             if (this.#conversationUrl === undefined) {
                 throw new CueLineError("TAB_RECOVERY_UNSAFE", "The ChatGPT tab disappeared before CueLine captured an exact conversation URL; refusing a potentially duplicate send.", {
                     cause: error,
@@ -390,13 +570,6 @@ class CodexIabAdapter {
                     },
                 });
             }
-            this.#tab = undefined;
-            if (context.stage === "pre_submit") {
-                const retryContext = { stage: "pre_submit" };
-                return this.#sendTurnOnce(input, retryContext, hooks).catch((retryError) => {
-                    throw this.#browserFailure(retryError, retryContext, input);
-                });
-            }
             if (!context.baseline || !context.selectedModelLabel)
                 throw error;
             try {
@@ -414,7 +587,7 @@ class CodexIabAdapter {
                         },
                     });
                 }
-                const completed = await this.#waitForCompletion(recoveredTab, context.baseline);
+                const completed = await this.#waitForCompletion(recoveredTab, context.baseline, input.signal);
                 return this.#resultFromCompletedTurn(recoveredTab, context.selectedModelLabel, completed);
             }
             catch (recoveryError) {
@@ -422,7 +595,24 @@ class CodexIabAdapter {
             }
         }
     }
-    async recoverTurn(input) {
+    async submitTurn(input, hooks) {
+        const context = { stage: "pre_submit" };
+        try {
+            await this.#submitTurnOnce(input, context, hooks, true);
+        }
+        catch (error) {
+            if (!isTabUnavailableError(error) || context.stage !== "pre_submit") {
+                throw this.#browserFailure(error, context, input);
+            }
+            this.#tab = undefined;
+            const retryContext = { stage: "pre_submit" };
+            await this.#submitTurnOnce(input, retryContext, hooks, true).catch((retryError) => {
+                throw this.#browserFailure(retryError, retryContext, input);
+            });
+        }
+    }
+    async #readExistingTurn(input, waitForCompletion) {
+        throwIfCancelled(input.signal);
         if (this.#conversationUrl === undefined) {
             throw new CueLineError("CONTROLLER_RECONCILIATION_URL_REQUIRED", "CueLine needs the exact persisted ChatGPT conversation URL to recover without sending.", {
                 details: {
@@ -432,32 +622,68 @@ class CodexIabAdapter {
                 },
             });
         }
+        const tab = await this.#getTab();
+        throwIfCancelled(input.signal);
+        const selectedModelLabel = await readComposerModelLabelWhenReady(tab, input.signal);
+        if (!isProLabel(selectedModelLabel)) {
+            throw new CueLineError("CONTROLLER_RECONCILIATION_MODEL_UNVERIFIED", "The existing conversation does not currently expose a Pro composer label; refusing to import the response without both model checks.");
+        }
+        const allowVisiblePromptMismatch = input.manualSendConfirmed === true || input.attachmentPromptExpected === true;
+        const baselineAssistantMessageCount = typeof input.baselineAssistantMessageCount === "number" &&
+            Number.isSafeInteger(input.baselineAssistantMessageCount) &&
+            input.baselineAssistantMessageCount >= 0
+            ? input.baselineAssistantMessageCount
+            : undefined;
+        const expectedIdentity = {
+            runId: input.runId, round: input.round, requestId: input.requestId,
+        };
+        const completed = waitForCompletion
+            ? await this.#waitForRecoveredCompletion(tab, input.prompt, allowVisiblePromptMismatch, input.manualSendConfirmed === true, baselineAssistantMessageCount, this.#conversationUrl, expectedIdentity, input.signal)
+            : await this.#observeRecoveredCompletion(tab, input.prompt, allowVisiblePromptMismatch, input.manualSendConfirmed === true, baselineAssistantMessageCount, this.#conversationUrl, expectedIdentity, input.signal);
+        if (completed === undefined)
+            return undefined;
+        const recoveredUrl = (await tab.url()) ?? "";
+        if (normalizedConversationUrl(recoveredUrl) !==
+            normalizedConversationUrl(this.#conversationUrl)) {
+            throw new CueLineError("CONTROLLER_RECONCILIATION_CONVERSATION_MISMATCH", "The recovered response is no longer on the exact persisted ChatGPT conversation URL.");
+        }
+        return this.#resultFromCompletedTurn(tab, selectedModelLabel, completed);
+    }
+    #reconciliationFailure(error, input) {
+        const message = error instanceof Error ? error.message : String(error);
+        const existingDetails = error instanceof CueLineError &&
+            typeof error.details === "object" &&
+            error.details !== null &&
+            !Array.isArray(error.details)
+            ? error.details
+            : {};
+        return new CueLineError(error instanceof CueLineError ? error.code : "IAB_RECONCILIATION_FAILED", message, {
+            cause: error,
+            details: {
+                ...existingDetails,
+                stage: "reconciling",
+                submission_state: "possibly_sent",
+                request_id: input.requestId,
+            },
+        });
+    }
+    async observeTurn(input) {
         try {
-            const tab = await this.#getTab();
-            const selectedModelLabel = await readComposerModelLabelWhenReady(tab);
-            if (!isProLabel(selectedModelLabel)) {
-                throw new CueLineError("CONTROLLER_RECONCILIATION_MODEL_UNVERIFIED", "The existing conversation does not currently expose a Pro composer label; refusing to import the response without both model checks.");
-            }
-            const completed = await this.#waitForRecoveredCompletion(tab, input.prompt);
-            return this.#resultFromCompletedTurn(tab, selectedModelLabel, completed);
+            return await this.#readExistingTurn(input, false);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const existingDetails = error instanceof CueLineError &&
-                typeof error.details === "object" &&
-                error.details !== null &&
-                !Array.isArray(error.details)
-                ? error.details
-                : {};
-            throw new CueLineError(error instanceof CueLineError ? error.code : "IAB_RECONCILIATION_FAILED", message, {
-                cause: error,
-                details: {
-                    ...existingDetails,
-                    stage: "reconciling",
-                    submission_state: "possibly_sent",
-                    request_id: input.requestId,
-                },
-            });
+            throw this.#reconciliationFailure(error, input);
+        }
+    }
+    async recoverTurn(input) {
+        try {
+            const turn = await this.#readExistingTurn(input, true);
+            if (turn === undefined)
+                throw new Error("IAB_RECOVERY_RETURNED_WITHOUT_RESPONSE");
+            return turn;
+        }
+        catch (error) {
+            throw this.#reconciliationFailure(error, input);
         }
     }
 }