cli-jaw 2.0.1 → 2.0.2

package/dist/src/browser/web-ai/chatgpt.js

@@ -1,14 +1,23 @@
-import { getActivePage, getCdpSession } from '../connection.js';
+import { getActivePage, getCdpSession, createTab, waitForPageByTargetId, getPageByTargetId, listTabs } from '../connection.js';
 import { getActiveTab } from '../connection.js';
+import { cleanupIdleTabs, isPinned } from '../tab-lifecycle.js';
+import { stripUndefined } from '../../core/strip-undefined.js';
+import { cleanupPoolTabs, getPooledTab } from './tab-pool.js';
+import { finalizeProviderTab } from './tab-finalizer.js';
+import { listLeases, recordActiveLease } from './tab-lease-store.js';
+import { withSessionCommandLock } from './session-store.js';
 import { basename } from 'node:path';
 import { statSync } from 'node:fs';
 import { countConversationTurns } from './chatgpt-composer.js';
 import { attachLocalFileLive, verifySentTurnAttachmentLive, } from './chatgpt-attachments.js';
 import { createChatGptEditorAdapter } from './vendor-editor-contract.js';
 import { normalizeEnvelope, renderQuestionEnvelope, renderQuestionEnvelopeWithContext } from './question.js';
-import { assertSameTarget, createSession, findSessionByTarget, getBaseline, getSession, listSessions, pruneSessions, saveBaseline, updateSessionResult, updateSessionStatus, } from './session.js';
+import { assertSameTarget, bindSessionToTab, createSession, findSessionByTarget, getBaseline, getSession, listSessions, pruneSessions, saveBaseline, updateSessionResult, updateSessionStatus, } from './session.js';
 import { captureAssistantResponse } from './chatgpt-response.js';
 import { selectChatGptModel } from './chatgpt-model.js';
+import { withAnswerArtifact } from './answer-artifact.js';
+import { auditSources } from './source-audit.js';
+import { resolveTargetForIntent } from './target-resolver.js';
 import { listActiveWebAiWatchers, resumeStoredWebAiWatchers, startWebAiWatcher } from './watcher.js';
 import { captureWebAiDiagnostics, } from './diagnostics.js';
 import { geminiSend, geminiPoll, geminiStop, geminiStatus } from './gemini-live.js';
@@ -17,6 +26,7 @@ import { ProviderRuntimeDisabledError } from './provider-adapter.js';
 import { fromCliJawStructuredError, WebAiError } from './errors.js';
 import { listCapabilitySchemas } from './capability-registry.js';
 import { prepareContextForBrowser, summarizeContextPack } from './context-pack/index.js';
+import { appendTraceToSession } from './trace-persistence.js';
 const CHATGPT_HOSTS = new Set(['chatgpt.com', 'chat.openai.com']);
 const ASSISTANT_SELECTORS = [
     '[data-message-author-role="assistant"]',
@@ -72,7 +82,7 @@ export async function status(port, input = {}) {
         const active = await requireVerifiedChatGptTab(port, vendor);
         inner = { ok: true, vendor: 'chatgpt', status: 'ready', url: active.url, warnings: [] };
     }
-    const allRows = listCapabilitySchemas({ vendor: vendor });
+    const allRows = listCapabilitySchemas({ vendor });
     const rows = input.probe
         ? allRows.filter((row) => row.capabilityId === input.probe)
         : allRows;
@@ -81,6 +91,117 @@ export async function status(port, input = {}) {
         capabilities: rows,
     };
 }
+async function ensureProviderTab(port, input) {
+    const reuseTab = input.reuseTab === true || process.env["JAW_REUSE_TAB"] === '1';
+    if (reuseTab) {
+        const active = await requireVerifiedChatGptTab(port, input.vendor);
+        const page = await requireActivePage(port);
+        return { page, targetId: active.targetId };
+    }
+    const vendor = (input.vendor || 'chatgpt');
+    const vendorUrl = input.url || 'https://chatgpt.com';
+    await cleanupPoolTabs(port);
+    await cleanupIdleTabs(port, { maxTabs: Number.POSITIVE_INFINITY });
+    if (input.newTab !== true) {
+        const pooled = await getPooledTab(port, vendor, {
+            owner: 'cli-jaw',
+            sessionType: 'jaw',
+            url: vendorUrl,
+        });
+        if (pooled) {
+            const page = await waitForPageByTargetId(port, pooled.targetId);
+            if (page.url?.() !== vendorUrl) {
+                await page.goto(vendorUrl, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+            }
+            return { page, targetId: pooled.targetId };
+        }
+        const reusable = await findReusableChatGptTab(port);
+        if (reusable?.targetId) {
+            const page = await waitForPageByTargetId(port, reusable.targetId);
+            if (page.url?.() !== vendorUrl) {
+                await page.goto(vendorUrl, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+            }
+            return { page, targetId: reusable.targetId };
+        }
+    }
+    const tab = await createTab(port, vendorUrl, { activate: false });
+    const page = await waitForPageByTargetId(port, tab.targetId);
+    return { page, targetId: tab.targetId };
+}
+async function findReusableChatGptTab(port) {
+    const activeSessions = new Set();
+    for (const session of [...listSessions({ status: 'sent' }), ...listSessions({ status: 'streaming' })]) {
+        if (session.targetId)
+            activeSessions.add(session.targetId);
+    }
+    const leases = await listLeases();
+    const leaseByTargetId = new Map(leases.map(lease => [lease.targetId, lease]));
+    const tabs = await listTabs(port);
+    return tabs
+        .filter(tab => tab.targetId && tab.type === 'page')
+        .filter(tab => !activeSessions.has(tab.targetId))
+        .filter(tab => !isPinned(tab.targetId))
+        .filter(tab => isReusableByLease(tab.targetId, leaseByTargetId))
+        .filter(tab => isChatGptUrl(tab.url || ''))
+        .sort((a, b) => (Number(b.lastActiveAt) || 0) - (Number(a.lastActiveAt) || 0))[0] || null;
+}
+function isReusableByLease(targetId, leaseByTargetId) {
+    const lease = leaseByTargetId.get(targetId);
+    if (!lease)
+        return true;
+    return ['cli-jaw', 'web-ai'].includes(lease.owner) &&
+        ['pooled', 'completed-session'].includes(lease.state);
+}
+async function withSessionPage(port, sessionId, fn) {
+    const session = getSession(sessionId);
+    if (!session)
+        throw new Error(`Session not found: ${sessionId}`);
+    async function resolvePage(forceRecover = false) {
+        const current = getSession(sessionId);
+        if (!current)
+            throw new Error(`Session not found: ${sessionId}`);
+        const alive = current.targetId ? !!(await getPageByTargetId(port, current.targetId).catch(() => null)) : false;
+        if (!alive || forceRecover) {
+            const tab = await createTab(port, current.conversationUrl || current.url || 'https://chatgpt.com', { activate: false });
+            const page = await waitForPageByTargetId(port, tab.targetId);
+            updateSessionResult({ sessionId, status: current.status, tabState: { createdAt: current.tabState?.createdAt || new Date().toISOString(), lastActiveAt: new Date().toISOString(), recoveryCount: (current.tabState?.recoveryCount || 0) + 1, closeCount: current.tabState?.closeCount || 0 } });
+            const recovered = getSession(sessionId);
+            return { page, targetId: tab.targetId, session: recovered || current };
+        }
+        const page = await getPageByTargetId(port, current.targetId);
+        if (!page)
+            throw new Error(`Session ${sessionId} page not found for targetId ${current.targetId}`);
+        return { page, targetId: current.targetId, session: current };
+    }
+    const first = await resolvePage();
+    try {
+        return await fn(first);
+    }
+    catch (err) {
+        const msg = errorMessage(err).toLowerCase();
+        const isPageDeath = msg.includes('target closed') || msg.includes('page closed') || msg.includes('browser has been closed') || msg.includes('crash');
+        if (!isPageDeath)
+            throw err;
+        const recovered = await resolvePage(true);
+        return fn(recovered);
+    }
+}
+async function runBoundCommand(port, command, input, pollFn, stopFn) {
+    if (['poll', 'stop'].includes(command) && input.session) {
+        const sessionId = input.session;
+        return withSessionCommandLock(sessionId, async () => {
+            return withSessionPage(port, sessionId, async ({ session }) => {
+                const boundInput = { ...input, vendor: session.vendor, session: session.sessionId };
+                return command === 'poll' ? pollFn(port, boundInput) : stopFn(port, boundInput);
+            });
+        });
+    }
+    if (command === 'poll')
+        return pollFn(port, input);
+    if (command === 'stop')
+        return stopFn(port, input);
+    throw new Error(`runBoundCommand: unsupported command ${command}`);
+}
 export async function send(port, input = {}) {
     const requestedVendor = parseVendor(input.vendor);
     if (requestedVendor === 'gemini') {
@@ -99,39 +220,49 @@ export async function send(port, input = {}) {
             throw stageError(e, 'send-click');
         }
     }
-    await navigateRequestedConversation(port, input.url, 'chatgpt');
     const envelope = normalizeEnvelope(input);
-    const active = await requireVerifiedChatGptTab(port, envelope.vendor);
-    const page = await requireActivePage(port);
+    const { page, targetId } = await ensureProviderTab(port, input);
     const contextPack = await prepareContextForBrowser(input);
     const rendered = contextPack
         ? contextPack.transport === 'inline'
             ? renderQuestionEnvelopeWithContext(envelope, contextPack.composerText)
             : renderQuestionEnvelope(envelope)
         : renderQuestionEnvelope(envelope);
-    const selectedModel = await selectChatGptModel(page, input.model);
+    const selectedModel = await selectChatGptModel(page, input.model, stripUndefined({ effort: input.reasoningEffort }));
     await waitForStableAssistantCount(page);
     const assistantCount = await countAssistantMessages(page);
     const baseline = saveBaseline({
         vendor: envelope.vendor,
-        targetId: active.targetId,
-        url: active.url,
+        targetId,
+        url: page.url(),
         envelope,
         assistantCount,
         textHash: String((await page.innerText('body').catch(() => '')).length),
     });
     const session = createSession({
         vendor: envelope.vendor,
-        targetId: active.targetId,
-        url: active.url,
-        conversationUrl: active.url,
+        targetId,
+        url: page.url(),
+        conversationUrl: page.url(),
         envelope,
         assistantCount,
         timeoutMs: 600_000,
     });
+    bindSessionToTab(session.sessionId, targetId);
+    await recordActiveLease({
+        owner: 'cli-jaw',
+        vendor: envelope.vendor,
+        sessionType: 'jaw',
+        port,
+        targetId,
+        sessionId: session.sessionId,
+        url: page.url(),
+    });
     const adapter = createChatGptEditorAdapter(page, {
         insertText: async (text) => {
             const cdp = await getCdpSession(port);
+            if (!cdp)
+                throw new Error('No CDP session available for text insertion');
             try {
                 await cdp.send('Input.insertText', { text });
             }
@@ -141,6 +272,13 @@ export async function send(port, input = {}) {
         },
     });
     try {
+        const composerTarget = await resolveTargetForIntent(page, {
+            provider: envelope.vendor,
+            intentId: 'composer.fill',
+        });
+        if (!composerTarget.ok && composerTarget.required) {
+            throw new Error(`composer target unresolved: ${composerTarget.errorCode || 'unknown'}`);
+        }
         await adapter.waitForReady();
         const commitBaseline = { turnsCount: await countConversationTurns(page).catch(() => assistantCount) };
         await adapter.insertPrompt(rendered.composerText);
@@ -150,11 +288,22 @@ export async function send(port, input = {}) {
         }
         const uploadPath = input.filePath || contextAttachmentPath;
         if (uploadPath) {
+            await resolveTargetForIntent(page, {
+                provider: envelope.vendor,
+                intentId: 'upload.attach',
+            }).catch(() => null);
             const info = localFileInfo(uploadPath);
             const uploaded = await attachLocalFileLive(page, info);
             if (!uploaded.ok)
                 throw new Error(uploaded.error);
         }
+        const sendTarget = await resolveTargetForIntent(page, {
+            provider: envelope.vendor,
+            intentId: 'send.click',
+        });
+        if (!sendTarget.ok && sendTarget.required) {
+            throw new Error(`send target unresolved: ${sendTarget.errorCode || 'unknown'}`);
+        }
         await adapter.submitPrompt();
         await adapter.verifyPromptCommitted(rendered.composerText, commitBaseline);
         if (uploadPath) {
@@ -168,11 +317,11 @@ export async function send(port, input = {}) {
         updateSessionStatus(session.sessionId, 'error');
         throw stageError(e, 'send-click');
     }
-    return {
+    return stripUndefined({
         ok: true,
         vendor: envelope.vendor,
         status: 'sent',
-        url: active.url,
+        url: page.url(),
         baseline,
         sessionId: session.sessionId,
         ...(contextPack ? { contextPack: summarizeContextPack(contextPack) } : {}),
@@ -182,8 +331,9 @@ export async function send(port, input = {}) {
             ...(contextPack?.warnings || []),
             ...(contextPack?.attachments?.[0] ? [`context package attached: ${contextPack.attachments[0].displayPath}`] : []),
             ...(selectedModel ? [`model selected: ${selectedModel.selected}${selectedModel.alreadySelected ? ' (already selected)' : ''}`] : []),
+            ...(selectedModel?.effort ? [`reasoning effort selected: ${selectedModel.effort}`] : []),
         ],
-    };
+    });
 }
 function localFileInfo(filePath) {
     const stat = statSync(filePath);
@@ -195,11 +345,11 @@ export async function poll(port, input = {}) {
     const vendor = parseVendor(input.vendor);
     if (vendor === 'gemini') {
         try {
-            return await geminiPoll(port, {
+            return decorateCompletedOutput(await geminiPoll(port, stripUndefined({
                 timeout: input.timeout,
                 session: input.session,
                 allowCopyMarkdownFallback: input.allowCopyMarkdownFallback === true,
-            });
+            })), input, 'poll');
         }
         catch (e) {
             throw stageError(e, 'poll-timeout');
@@ -207,19 +357,31 @@ export async function poll(port, input = {}) {
     }
     if (vendor === 'grok') {
         try {
-            return await grokPoll(port, {
+            return decorateCompletedOutput(await grokPoll(port, stripUndefined({
                 timeout: input.timeout,
                 session: input.session,
                 allowCopyMarkdownFallback: input.allowCopyMarkdownFallback === true,
-            });
+            })), input, 'poll');
         }
         catch (e) {
             throw stageError(e, 'poll-timeout');
         }
     }
-    const active = await requireVerifiedChatGptTab(port, vendor);
-    let session = input.session ? getSession(input.session) : findSessionByTarget(vendor, active.targetId);
-    const baseline = getBaseline(vendor, active.targetId);
+    let page;
+    let targetId;
+    let session = input.session ? getSession(input.session) : null;
+    if (session) {
+        const ctx = await withSessionPage(port, session.sessionId, async (c) => c);
+        page = ctx.page;
+        targetId = ctx.targetId;
+    }
+    else {
+        const active = await requireVerifiedChatGptTab(port, vendor);
+        targetId = active.targetId;
+        page = await requireActivePage(port);
+        session = findSessionByTarget(vendor, targetId);
+    }
+    const baseline = getBaseline(vendor, targetId);
     if (!baseline)
         throw new WebAiError({
             errorCode: 'provider.poll-timeout',
@@ -229,8 +391,8 @@ export async function poll(port, input = {}) {
             message: 'baseline required. Run web-ai send or query first.',
         });
     if (session)
-        assertSameTarget(session, active.targetId);
-    const page = await requireActivePage(port);
+        assertSameTarget(session, targetId);
+    const currentUrl = page.url?.() || session?.url || 'https://chatgpt.com';
     const timeoutMs = Math.max(1, Number(input.timeout || 1200)) * 1000;
     const result = await captureAssistantResponse(page, {
         minTurnIndex: baseline.assistantCount,
@@ -242,57 +404,150 @@ export async function poll(port, input = {}) {
         updateSessionStatus(session.sessionId, 'complete');
     if (session && !result.ok)
         updateSessionStatus(session.sessionId, 'timeout');
+    const traceSummary = session
+        ? appendTraceToSession(session.sessionId, (result.resolverTrace || []))
+        : null;
     if (result.canvas) {
-        if (session)
-            updateSessionResult({ sessionId: session.sessionId, status: 'complete', url: active.url, conversationUrl: active.url, answerText: result.answerText });
-        return {
+        if (session) {
+            await finalizeProviderTab({ vendor, session, port, url: currentUrl, answerText: result.answerText || '' });
+        }
+        const output = decorateCompletedOutput(stripUndefined({
             ok: true,
             vendor,
             status: 'complete',
-            url: active.url,
+            url: currentUrl,
             answerText: result.answerText,
             canvas: result.canvas,
             baseline,
             ...(session ? { sessionId: session.sessionId } : {}),
+            ...(traceSummary ? { traceSummary } : {}),
             usedFallbacks: result.usedFallbacks,
             warnings: result.warnings,
-        };
+        }), input, 'poll');
+        if (session)
+            updateSessionResult(stripUndefined({
+                sessionId: session.sessionId,
+                status: 'complete',
+                answerText: output.answerText,
+                answerArtifact: output.answerArtifact,
+                sourceAudit: output.sourceAudit,
+            }));
+        return output;
     }
     if (result.ok) {
-        if (session)
-            updateSessionResult({ sessionId: session.sessionId, status: 'complete', url: active.url, conversationUrl: active.url, answerText: result.answerText });
-        return {
+        if (session) {
+            await finalizeProviderTab({ vendor, session, port, url: currentUrl, answerText: result.answerText || '' });
+        }
+        const output = decorateCompletedOutput(stripUndefined({
             ok: true,
             vendor,
             status: 'complete',
-            url: active.url,
+            url: currentUrl,
             answerText: result.answerText,
             baseline,
             ...(session ? { sessionId: session.sessionId } : {}),
+            ...(traceSummary ? { traceSummary } : {}),
             usedFallbacks: result.usedFallbacks,
             warnings: result.warnings,
-        };
+        }), input, 'poll');
+        if (session)
+            updateSessionResult(stripUndefined({
+                sessionId: session.sessionId,
+                status: 'complete',
+                answerText: output.answerText,
+                answerArtifact: output.answerArtifact,
+                sourceAudit: output.sourceAudit,
+            }));
+        return output;
     }
     return {
         ok: false,
         vendor,
         status: 'timeout',
-        url: active.url,
+        url: currentUrl,
         baseline,
         ...(session ? { sessionId: session.sessionId, next: 'poll' } : {}),
+        ...(traceSummary ? { traceSummary } : {}),
         usedFallbacks: result.usedFallbacks,
         warnings: result.warnings,
         error: 'timed out waiting for answer',
     };
 }
+function decorateCompletedOutput(result, input, command) {
+    const withArtifact = withAnswerArtifact(result, {
+        provider: result.vendor || input.vendor,
+        sessionId: result.sessionId,
+        conversationUrl: result.url,
+    });
+    if (input.requireSourceAudit !== true)
+        return withArtifact;
+    const answerText = withArtifact.answerText || withArtifact.answerArtifact?.text || withArtifact.answerArtifact?.markdown || '';
+    if (!answerText && withArtifact.ok === false)
+        return withArtifact;
+    if (!answerText) {
+        throw new WebAiError({
+            errorCode: 'source-audit.answer-missing',
+            stage: 'source-audit',
+            vendor: result.vendor || parseVendor(input.vendor),
+            retryHint: 'poll-or-disable-audit',
+            message: `source audit requires completed answer text for web-ai ${command}`,
+            mutationAllowed: false,
+            evidence: { status: result.status || null },
+        });
+    }
+    const sourceAudit = auditSources(answerText, {
+        requiredSourceRatio: parseSourceAuditRatio(input.sourceAuditRatio),
+        checkedScope: input.sourceAuditScope || null,
+        checkedDate: input.sourceAuditDate || null,
+    });
+    withArtifact.sourceAudit = sourceAudit;
+    if (!sourceAudit.ok) {
+        throw new WebAiError({
+            errorCode: 'source-audit.failed',
+            stage: 'source-audit',
+            vendor: result.vendor || parseVendor(input.vendor),
+            retryHint: 'add-inline-sources-or-disable-audit',
+            message: `source audit failed: ${sourceAudit.gaps.map(gap => gap.code).join(', ')}`,
+            mutationAllowed: false,
+            evidence: {
+                gaps: sourceAudit.gaps,
+                claimCount: sourceAudit.claims.length,
+                unsourcedClaimCount: sourceAudit.unsourcedClaims.length,
+                checkedScope: sourceAudit.checkedScope,
+                checkedDate: sourceAudit.checkedDate,
+            },
+        });
+    }
+    return withArtifact;
+}
+function parseSourceAuditRatio(value) {
+    if (value === undefined || value === null || value === '')
+        return 1;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        throw new WebAiError({
+            errorCode: 'source-audit.invalid-ratio',
+            stage: 'source-audit',
+            retryHint: 'fix-source-audit-ratio',
+            message: '--source-audit-ratio must be a number between 0 and 1',
+            mutationAllowed: false,
+            evidence: { value },
+        });
+    }
+    return parsed;
+}
 export async function query(port, input = {}) {
     const sent = await send(port, input);
-    const result = await poll(port, {
+    const result = await poll(port, stripUndefined({
         vendor: sent.vendor,
         timeout: input.timeout,
         session: sent.sessionId,
         allowCopyMarkdownFallback: input.allowCopyMarkdownFallback,
-    });
+        requireSourceAudit: input.requireSourceAudit,
+        sourceAuditRatio: input.sourceAuditRatio,
+        sourceAuditScope: input.sourceAuditScope,
+        sourceAuditDate: input.sourceAuditDate,
+    }));
     return {
         ...result,
         usedFallbacks: [...(sent.usedFallbacks || []), ...(result.usedFallbacks || [])],
@@ -310,7 +565,7 @@ export async function watch(port, input = {}) {
             sessionId: input.session,
             timeoutMs: Math.max(1, Number(input.timeout || 1200)) * 1000,
             pollIntervalSeconds: Number(input.pollIntervalSeconds || 30),
-            allowCopyMarkdownFallback: input.allowCopyMarkdownFallback,
+            ...(input.allowCopyMarkdownFallback !== undefined ? { allowCopyMarkdownFallback: input.allowCopyMarkdownFallback } : {}),
             pollOnce: (pollInput) => poll(port, pollInput),
         });
         return {
@@ -337,7 +592,7 @@ export function resumeStoredWatchers(port, input = {}) {
     const vendor = input.vendor ? parseVendor(input.vendor) : undefined;
     const resumed = resumeStoredWebAiWatchers({
         port,
-        vendor,
+        ...(vendor ? { vendor } : {}),
         pollIntervalSeconds: Number(input.pollIntervalSeconds || 30),
         pollOnce: (pollInput) => poll(port, pollInput),
     });
@@ -351,22 +606,22 @@ export function resumeStoredWatchers(port, input = {}) {
 }
 export async function sessions(input = {}) {
     const vendor = input.vendor ? parseVendor(input.vendor) : undefined;
-    const status = input.status;
+    const status = parseSessionStatus(input.status);
     return {
         ok: true,
         vendor: vendor || 'chatgpt',
         status: 'ready',
-        sessions: listSessions({ vendor, status }),
+        sessions: listSessions(stripUndefined({ vendor, status })),
         warnings: [],
     };
 }
 export async function sessionsPrune(input = {}) {
     const ms = typeof input.olderThanMs === 'string' ? Number(input.olderThanMs) : input.olderThanMs;
-    const result = pruneSessions({
+    const result = pruneSessions(stripUndefined({
         ...(typeof ms === 'number' && Number.isFinite(ms) ? { olderThanMs: ms } : {}),
         ...(input.before ? { before: input.before } : {}),
-        ...(input.status ? { status: input.status } : {}),
-    });
+        ...(parseSessionStatus(input.status) ? { status: parseSessionStatus(input.status) } : {}),
+    }));
     return {
         ok: true,
         vendor: 'chatgpt',
@@ -393,15 +648,27 @@ export async function stop(port, input = {}) {
             throw stageError(e, 'send-click');
         }
     }
-    const active = await requireVerifiedChatGptTab(port, vendor);
-    const page = await requireActivePage(port);
-    const session = findSessionByTarget(vendor, active.targetId);
+    let page;
+    let targetId;
+    let session = input.session ? getSession(input.session) : null;
+    if (session) {
+        const ctx = await withSessionPage(port, session.sessionId, async (c) => c);
+        page = ctx.page;
+        targetId = ctx.targetId;
+    }
+    else {
+        const active = await requireVerifiedChatGptTab(port, vendor);
+        targetId = active.targetId;
+        page = await requireActivePage(port);
+        session = findSessionByTarget(vendor, targetId);
+    }
     if (session)
-        assertSameTarget(session, active.targetId);
+        assertSameTarget(session, targetId);
     await page.keyboard.press('Escape');
     if (session)
         updateSessionStatus(session.sessionId, 'complete');
-    return { ok: true, vendor: 'chatgpt', status: 'blocked', url: active.url, warnings: ['sent Escape to stop generation'] };
+    const currentUrl = page.url?.() || session?.url || 'https://chatgpt.com';
+    return { ok: true, vendor: 'chatgpt', status: 'blocked', url: currentUrl, warnings: ['sent Escape to stop generation'] };
 }
 export async function diagnose(port, input = {}) {
     const vendor = parseVendor(input.vendor);
@@ -445,6 +712,15 @@ function parseVendor(vendor) {
         evidence: { vendor },
     });
 }
+function parseSessionStatus(status) {
+    if (status === 'sent' || status === 'streaming' || status === 'complete' || status === 'timeout' || status === 'error') {
+        return status;
+    }
+    return undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error ?? '');
+}
 async function requireVerifiedChatGptTab(port, vendor) {
     const parsed = parseVendor(vendor);
     if (parsed === 'gemini') {