@moretea-labs/forge 1.8.0 → 1.8.1

package/adapters/chatgpt/browser-delivery-runtime.ts

@@ -2,16 +2,27 @@ import { randomUUID } from 'crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { ExecutionJobOrigin } from '../../src/runtime/execution/jobs/types';
 import { browserActions } from '../../src/runtime/plugins/browser-manifest-surface';
-import { controllerPluginRepository, executeControllerScopedPluginAction, getControllerPluginManifest, submitAssistantPluginAction } from '../../src/runtime/plugins/store';
+import { executeControllerScopedPluginAction, getControllerPluginManifest, submitControllerPluginAction } from '../../src/runtime/plugins/store';
 import {
+  CHATGPT_AUTOMATION_RATE_LIMITED,
+  CHATGPT_AUTOMATION_RATE_LIMITED_AFTER_SUBMIT,
   CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN,
   ChatgptProviderDeliveryError,
+  chatgptProviderPageFailure,
   DEFAULT_CHATGPT_AUTOMATION_MODEL,
   type ChatgptAutomationReasoning,
   type ChatgptAutomationTabCleanupStatus,
+  type ChatgptProviderPageFailureCode,
 } from './provider-delivery';
 
-const DEFAULT_CHATGPT_AUTOMATION_PLUGIN_MENTION = '@forge';
+// The installed/connected primary Forge plugin is `forge`, not the separate
+// Plugin Creator package `forge-current-1-8-1` or the Forge Recovery app.
+// Live ChatGPT selection yields an exact app:// ProseMirror Forge chip.
+const CHATGPT_FORGE_PLUGIN_SLUG = 'forge';
+const CHATGPT_FORGE_PLUGIN_LABEL = 'forge';
+const CHATGPT_FORGE_PLUGIN_PATH = 'app://asdk_app_6ac09022b26081918f20ff868c773824';
+const CHATGPT_PLUGIN_PICKER_OPTIONS = '[data-mention-section-id="plugins"] [data-mention-section-items] > button';
+
 
 type ChatgptBrowserActionOrigin = Pick<ExecutionJobOrigin, 'surface' | 'actor'>;
 interface ChatgptBrowserActionContext {
@@ -28,16 +39,20 @@ export function withChatgptBrowserActionOrigin<T>(
   return chatgptBrowserActionOrigin.run({ origin, authorizationGrantRefs }, operation);
 }
 
-function withForgePluginMention(prompt: string): string {
-  const value = prompt.trim();
+/** Strip the legacy text trigger; only a real ChatGPT app chip selects Forge. */
+export function chatgptSupervisorPromptBody(prompt: string): string {
+  const value = prompt.trim().replace(/^@forge(?:[ \t]*\r?\n|[ \t]+|$)/i, '').trim();
   if (!value) throw new Error('CHATGPT_AUTOMATION_PROMPT_REQUIRED');
-  if (/^@forge(?:\s|$)/i.test(value)) return value;
-  return `${DEFAULT_CHATGPT_AUTOMATION_PLUGIN_MENTION} ${value}`;
+  return value;
 }
 
-const CHATGPT_PROMPT_SELECTOR = 'div#prompt-textarea[contenteditable="true"]';
-const CHATGPT_SEND_SELECTOR = '[data-testid="send-button"], button[aria-label*="Send"], button[data-testid*="send"]';
-const CHATGPT_USER_MESSAGE_SELECTOR = '[data-message-author-role="user"]';
+// ChatGPT's composer is a ProseMirror textbox; the historical #prompt-textarea id is no longer stable.
+// Bind delivery to the semantic composer contract used by the live UI so readiness, fill, and Enter fallback share one selector authority.
+const CHATGPT_PROMPT_SELECTOR = '[data-composer-markdown][role="textbox"][contenteditable="true"]';
+const CHATGPT_SEND_SELECTOR = '[data-testid="send-button"], button[aria-label="Send"], button[aria-label="发送"], button[data-testid*="send"]';
+const CHATGPT_USER_MESSAGE_SELECTOR = '[data-message-author-role="user"], [data-chatgpt-search-unit-key$=":user"], [data-content-search-unit-key$=":user"]';
+const CHATGPT_ASSISTANT_MESSAGE_SELECTOR = '[data-message-author-role="assistant"], [data-chatgpt-search-unit-key$=":assistant"], [data-content-search-unit-key$=":assistant"]';
+const CHATGPT_STOP_GENERATING_SELECTOR = '[data-testid="stop-button"], button[aria-label*="Stop"]';
 const CHATGPT_INTELLIGENCE_CONTROL_SELECTORS = [
   'main button, main [role="button"]',
   'button, [role="button"]',
@@ -55,16 +70,15 @@ const CHATGPT_BROWSER_AUTHORIZATION_ACTIONS = new Set(
     .map((action) => action.actionId),
 );
 
-const CHATGPT_BROWSER_TRANSPORT_OVERRIDES = {
-  browser_mode: 'attach_preferred',
-  cdp_attach_fallback: 'fail_closed',
-  native_attach_mode: 'auto',
-  native_browser_candidates: ['chrome'],
-} as const;
-
 export function chatgptBrowserActionArgs(actionId: string, args: Record<string, unknown>): Record<string, unknown> {
-  if (actionId === 'configure' || actionId === 'list_sessions' || actionId === 'reconcile_sessions') return args;
-  return { ...args, ...CHATGPT_BROWSER_TRANSPORT_OVERRIDES };
+  // Browser transport policy is controller-scoped configuration. Do not copy
+  // it into every action envelope: older Browser action schemas legitimately
+  // reject these optional fields even though the persisted configuration still
+  // supports the same policy. Keeping the envelope action-specific also lets a
+  // resumed ChatGPT round cross a connector/schema rotation without failing
+  // before the provider can observe the conversation.
+  void actionId;
+  return args;
 }
 
 export function chatgptBrowserActionResult(envelope: Record<string, unknown>, actionId: string): Record<string, unknown> {
@@ -97,11 +111,7 @@ async function controllerBrowserAction(
   // reusable controller-scoped Browser grant. Scheduled delivery stays on the
   // low-level executor and must present explicit refs already bound to this Work.
   if (origin.surface === 'chatgpt-action' && CHATGPT_BROWSER_AUTHORIZATION_ACTIONS.has(actionId)) {
-    const submitted = await submitAssistantPluginAction(
-      controllerHome,
-      controllerPluginRepository(controllerHome),
-      actionRequest,
-    );
+    const submitted = await submitControllerPluginAction(controllerHome, actionRequest);
     const grantId = submitted.authorization?.grantId?.trim();
     if (grantId) context?.authorizationGrantRefs.add(grantId);
     if (!submitted.result) throw new Error(`CHATGPT_BROWSER_ACTION_RESULT_INVALID:${actionId}`);
@@ -155,17 +165,31 @@ function normalizeChatgptOutboundText(value: string): string {
 const CHATGPT_OUTBOUND_MESSAGE_UI_SUFFIXES = ['收起', 'Collapse', 'Show less'] as const;
 const MAX_CHATGPT_OUTBOUND_VERIFICATION_CHARS = 100_000;
 const MIN_TRUNCATED_CHATGPT_OUTBOUND_PREFIX_CHARS = 256;
+const CHATGPT_PROVIDER_ERROR_SELECTOR = '[role="alert"], [aria-live="assertive"], [data-testid*="error"], [data-testid*="toast"], [data-sonner-toast]';
+const CHATGPT_DELIVERY_FAILURE_PROBE_INTERVAL_MS = 1_000;
+
+interface BrowserFailedRequest {
+  url?: string;
+  method?: string;
+  status?: number;
+  failure?: string;
+}
+
+type ChatgptFailedRequestBaseline = Map<string, number>;
 
 export function chatgptOutboundMessageMatchesPrompt(
   messageText: string,
   prompt: string,
-  options: { truncated?: boolean } = {},
+  options: { truncated?: boolean; boundForgePlugin?: boolean } = {},
 ): boolean {
   const message = normalizeChatgptOutboundText(messageText);
   const normalizedPrompt = normalizeChatgptOutboundText(prompt);
   if (!message || !normalizedPrompt) return false;
-  if (message === normalizedPrompt) return true;
-  if (CHATGPT_OUTBOUND_MESSAGE_UI_SUFFIXES.some((suffix) => message === `${normalizedPrompt} ${suffix}`)) return true;
+  const candidatePrompts = [normalizedPrompt,
+    ...(options.boundForgePlugin ? [`${normalizedPrompt} ${CHATGPT_FORGE_PLUGIN_LABEL}`] : []),
+  ];
+  if (candidatePrompts.some((candidate) => message === candidate)) return true;
+  if (candidatePrompts.some((candidate) => CHATGPT_OUTBOUND_MESSAGE_UI_SUFFIXES.some((suffix) => message === `${candidate} ${suffix}`))) return true;
   // Browser text extraction is deliberately bounded. A large ControllerRound
   // prompt can exceed that bound, so requiring exact equality makes successful
   // submissions mechanically unverifiable. Accept only an explicitly reported
@@ -173,7 +197,138 @@ export function chatgptOutboundMessageMatchesPrompt(
   // remains insufficient evidence.
   return options.truncated === true
     && message.length >= MIN_TRUNCATED_CHATGPT_OUTBOUND_PREFIX_CHARS
-    && normalizedPrompt.startsWith(message);
+    && candidatePrompts.some((candidate) => candidate.startsWith(message));
+}
+
+export function chatgptAutomationDeliveryFailure(
+  bodyText: string | undefined,
+): ChatgptProviderPageFailureCode | undefined {
+  return chatgptProviderPageFailure(bodyText);
+}
+
+export function chatgptSubmissionSettlementWaitBudget(timeoutMs?: number): number {
+  return Math.min(Math.max(timeoutMs ?? 30_000, 3_000), 30_000);
+}
+
+export function chatgptSubmissionObservationDelayMs(observationIndex: number): number {
+  const schedule = [500, 1_000, 2_000, 3_000, 5_000] as const;
+  return schedule[Math.min(Math.max(0, Math.trunc(observationIndex)), schedule.length - 1)];
+}
+
+export function chatgptSubmissionAcceptanceObserved(input: {
+  outboundConfirmed: boolean;
+  hasConversationIdentity: boolean;
+  assistantResponseObserved: boolean;
+  generationInProgress: boolean;
+}): boolean {
+  return input.outboundConfirmed
+    && input.hasConversationIdentity
+    && (input.assistantResponseObserved || input.generationInProgress);
+}
+
+export function chatgptComposerRetainsPrompt(
+  composerText: string | undefined,
+  prompt: string,
+): boolean {
+  if (composerText === undefined) return false;
+  const composer = normalizeChatgptOutboundText(composerText);
+  const expected = normalizeChatgptOutboundText(prompt);
+  return Boolean(composer && expected && composer === expected);
+}
+
+async function currentChatgptComposerText(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<string | undefined> {
+  const result = await controllerBrowserAction(controllerHome, workId, 'get_text', {
+    session_id: browserSessionId,
+    selector: CHATGPT_PROMPT_SELECTOR,
+    max_chars: MAX_CHATGPT_OUTBOUND_VERIFICATION_CHARS,
+    timeout_ms: Math.min(timeoutMs ?? 3_000, 3_000),
+  }, timeoutMs).catch(() => undefined);
+  return typeof result?.text === 'string' ? result.text : undefined;
+}
+
+async function currentChatgptComposerHtml(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<string | undefined> {
+  const result = await controllerBrowserAction(controllerHome, workId, 'get_html', {
+    session_id: browserSessionId,
+    selector: CHATGPT_PROMPT_SELECTOR,
+    max_chars: MAX_CHATGPT_OUTBOUND_VERIFICATION_CHARS,
+    timeout_ms: Math.min(timeoutMs ?? 3_000, 3_000),
+  }, timeoutMs).catch(() => undefined);
+  return typeof result?.text === 'string' && result.truncated !== true ? result.text : undefined;
+}
+
+/** A real ChatGPT plugin mention is a non-editable ProseMirror app chip, not @ text. */
+export function chatgptForgePluginMentionBound(
+  composerHtml: string | undefined,
+  composerText: string | undefined,
+  prompt: string,
+): boolean {
+  if (!composerHtml || !composerText) return false;
+  const chips = [...composerHtml.matchAll(/\b(?:plugin|app)-mention-name="([^"]+)"/g)].map((match) => match[1]);
+  if (chips.length !== 1 || chips[0] !== CHATGPT_FORGE_PLUGIN_SLUG
+    || !composerHtml.includes(`app-mention-path="${CHATGPT_FORGE_PLUGIN_PATH}"`)) return false;
+  const normalized = normalizeChatgptOutboundText(composerText);
+  const payload = normalizeChatgptOutboundText(prompt);
+  return normalized === `${payload} ${CHATGPT_FORGE_PLUGIN_LABEL}`;
+}
+
+/** Return the single exact main-Forge suggestion after normalizing UI line breaks. */
+export function chatgptForgePluginPickerIndex(labels: string[]): number | undefined {
+  const matches = labels.flatMap((label, index) => {
+    const value = normalizeChatgptOutboundText(label);
+    return value === CHATGPT_FORGE_PLUGIN_LABEL || value.startsWith(`${CHATGPT_FORGE_PLUGIN_LABEL} `)
+      ? [index] : [];
+  });
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
+/** Browser owns DOM actions; Supervisor remains the only effect and delivery owner. */
+async function bindChatgptForgePluginMention(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  prompt: string,
+  targetUrl: string,
+  timeoutMs?: number,
+): Promise<void> {
+  const baseArgs = { session_id: browserSessionId, timeout_ms: timeoutMs ?? 60_000 };
+  // The payload and final standalone @ paragraph were inserted together.
+  // ProseMirror drops the leading whitespace of a later ` @` insertion.
+  await controllerBrowserAction(controllerHome, workId, 'type', {
+    ...baseArgs, selector: CHATGPT_PROMPT_SELECTOR, text: CHATGPT_FORGE_PLUGIN_LABEL,
+    post_action_wait_ms: 120,
+  }, timeoutMs);
+  const entries = await controllerBrowserAction(controllerHome, workId, 'query_all', {
+    ...baseArgs, selector: CHATGPT_PLUGIN_PICKER_OPTIONS, limit: 80,
+  }, timeoutMs);
+  const index = chatgptForgePluginPickerIndex(queryMatches(entries).map(matchText));
+  if (index === undefined) {
+    throw new ChatgptProviderDeliveryError('CHATGPT_AUTOMATION_PLUGIN_NOT_IN_PICKER',
+      `CHATGPT_AUTOMATION_PLUGIN_NOT_IN_PICKER:${CHATGPT_FORGE_PLUGIN_SLUG}:${targetUrl}`,
+      { conversationUrl: targetUrl });
+  }
+  // The option order was observed from this exact open picker. Never select
+  // another Forge-prefixed app as a fallback; verify the resulting app chip.
+  await controllerBrowserAction(controllerHome, workId, 'click', {
+    ...baseArgs, selector: `${CHATGPT_PLUGIN_PICKER_OPTIONS}:nth-of-type(${index + 1})`,
+  }, timeoutMs);
+  const [composerHtml, composerText] = await Promise.all([
+    currentChatgptComposerHtml(controllerHome, workId, browserSessionId, timeoutMs),
+    currentChatgptComposerText(controllerHome, workId, browserSessionId, timeoutMs),
+  ]);
+  if (!chatgptForgePluginMentionBound(composerHtml, composerText, prompt)) {
+    throw new ChatgptProviderDeliveryError('CHATGPT_AUTOMATION_PLUGIN_MENTION_UNVERIFIED',
+      `CHATGPT_AUTOMATION_PLUGIN_MENTION_UNVERIFIED:${targetUrl}`, { conversationUrl: targetUrl });
+  }
 }
 
 async function latestChatgptUserMessage(
@@ -213,8 +368,138 @@ async function fullChatgptMessageText(
   };
 }
 
+async function latestChatgptAssistantMessage(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<{ selector?: string; preview: string }> {
+  const result = await controllerBrowserAction(controllerHome, workId, 'query_all', {
+    session_id: browserSessionId,
+    selector: CHATGPT_ASSISTANT_MESSAGE_SELECTOR,
+    limit: 1,
+    from_end: true,
+    timeout_ms: Math.min(timeoutMs ?? 3_000, 3_000),
+  }, timeoutMs);
+  const latest = queryMatches(result).at(-1);
+  return { selector: matchSelector(latest), preview: latest ? matchText(latest) : '' };
+}
+
+function chatgptMessageObservationChanged(
+  before: { selector?: string; preview: string },
+  latest: { selector?: string; preview: string },
+): boolean {
+  return Boolean(
+    (latest.selector && latest.selector !== before.selector)
+    || (!before.preview && latest.preview)
+    || latest.preview !== before.preview,
+  );
+}
+
+async function chatgptGenerationInProgress(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<boolean> {
+  const result = await controllerBrowserAction(controllerHome, workId, 'query_all', {
+    session_id: browserSessionId,
+    selector: CHATGPT_STOP_GENERATING_SELECTOR,
+    limit: 1,
+    timeout_ms: Math.min(timeoutMs ?? 1_000, 1_000),
+  }, timeoutMs).catch(() => undefined);
+  return queryMatches(result).length > 0;
+}
+
+function failedRequestKey(request: BrowserFailedRequest): string {
+  return `${request.method?.toUpperCase() ?? ''}|${request.status ?? ''}|${request.url ?? ''}|${request.failure ?? ''}`;
+}
+
+/** Only provider requests causally inside the current send pipeline may classify that send as rate-limited. */
+export function chatgptFailedRequestIsCausalRateLimit(request: Pick<BrowserFailedRequest, 'url' | 'method' | 'status'>): boolean {
+  if (request.status !== 429 || request.method?.trim().toUpperCase() !== 'POST') return false;
+  try {
+    const url = new URL(request.url ?? '');
+    if (url.protocol !== 'https:' || url.hostname !== 'chatgpt.com') return false;
+    const path = url.pathname.toLowerCase();
+    return /^\/backend-api\/(?:f\/)?conversation(?:\/|$)/.test(path)
+      || path === '/backend-api/sentinel/chat-requirements';
+  } catch {
+    return false;
+  }
+}
+
+async function chatgptFailedRequestBaseline(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<ChatgptFailedRequestBaseline | undefined> {
+  const result = await controllerBrowserAction(controllerHome, workId, 'get_failed_requests', {
+    session_id: browserSessionId,
+    timeout_ms: Math.min(timeoutMs ?? 2_000, 2_000),
+  }, timeoutMs).catch(() => undefined);
+  if (!result || !Array.isArray(result.failedRequests)) return undefined;
+  const baseline = new Map<string, number>();
+  for (const request of result.failedRequests) {
+    if (!request || typeof request !== 'object') continue;
+    const key = failedRequestKey(request as BrowserFailedRequest);
+    baseline.set(key, (baseline.get(key) ?? 0) + 1);
+  }
+  return baseline;
+}
+
+async function chatgptProviderFailureOnErrorUi(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<ChatgptProviderPageFailureCode | undefined> {
+  const result = await controllerBrowserAction(controllerHome, workId, 'query_all', {
+    session_id: browserSessionId,
+    selector: CHATGPT_PROVIDER_ERROR_SELECTOR,
+    limit: 20,
+    timeout_ms: Math.min(timeoutMs ?? 2_000, 2_000),
+  }, timeoutMs).catch(() => undefined);
+  for (const match of queryMatches(result)) {
+    const failure = chatgptAutomationDeliveryFailure(matchText(match));
+    if (failure) return failure;
+  }
+  return undefined;
+}
+
+async function chatgptDeliveryFailureOnPage(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  failedRequestBaseline: ChatgptFailedRequestBaseline | undefined,
+  timeoutMs?: number,
+): Promise<ChatgptProviderPageFailureCode | undefined> {
+  const uiFailure = await chatgptProviderFailureOnErrorUi(controllerHome, workId, browserSessionId, timeoutMs);
+  if (uiFailure) return uiFailure;
+  if (!failedRequestBaseline) return undefined;
+
+  const current = await controllerBrowserAction(controllerHome, workId, 'get_failed_requests', {
+    session_id: browserSessionId,
+    timeout_ms: Math.min(timeoutMs ?? 2_000, 2_000),
+  }, timeoutMs).catch(() => undefined);
+  if (!current || !Array.isArray(current.failedRequests)) return undefined;
+  const seen = new Map<string, number>();
+  for (const value of current.failedRequests) {
+    if (!value || typeof value !== 'object') continue;
+    const request = value as BrowserFailedRequest;
+    const key = failedRequestKey(request);
+    const occurrence = (seen.get(key) ?? 0) + 1;
+    seen.set(key, occurrence);
+    const baselineCount = failedRequestBaseline.get(key) ?? 0;
+    if (occurrence <= baselineCount) continue;
+    if (chatgptFailedRequestIsCausalRateLimit(request)) return CHATGPT_AUTOMATION_RATE_LIMITED;
+  }
+  return undefined;
+}
+
 function chatgptSendControlUnavailable(error: unknown): boolean {
-  return error instanceof Error && (error.message.includes('Selector') && error.message.includes('not found'));
+  return error instanceof Error && error.message.includes('PLUGIN_BROWSER_SELECTOR_UNAVAILABLE');
 }
 
 function normalizeExecutionControlLabel(label: string | undefined): string {
@@ -438,7 +723,7 @@ export async function ensureChatgptExecutionPreference(
   for (let index = 0; index < Math.abs(targetValue - currentValue); index += 1) {
     await controllerBrowserAction(controllerHome, workId, 'press', {
       session_id: browserSessionId,
-      selector: CHATGPT_CAPABILITY_MENUITEM_SELECTOR,
+      selector: CHATGPT_CAPABILITY_SLIDER_SELECTOR,
       key: direction,
       timeout_ms: timeoutMs ?? 60_000,
       post_action_wait_ms: 120,
@@ -502,6 +787,42 @@ function chatgptUrlMatchesContinuationTarget(observedUrl: string, targetUrl: str
   }
 }
 
+/** The saved Browser session id is not proof of the live native tab identity. */
+export function chatgptBrowserObservationMatchesTarget(
+  observation: Record<string, unknown>,
+  browserSessionId: string,
+  targetUrl: string,
+): boolean {
+  const observedSessionId = stringField(observation.sessionId) ?? resultSessionId(observation);
+  if (observedSessionId && observedSessionId !== browserSessionId) return false;
+  const connection = observation.browserConnection;
+  const liveTab = connection && typeof connection === 'object'
+    ? (connection as Record<string, unknown>).tab : undefined;
+  const liveTabUrl = liveTab && typeof liveTab === 'object'
+    ? stringField((liveTab as Record<string, unknown>).url) : undefined;
+  const urls = [resultUrl(observation), liveTabUrl].filter((url): url is string => Boolean(url));
+  return urls.length > 0 && urls.every((url) => chatgptUrlMatchesContinuationTarget(url, targetUrl));
+}
+
+async function verifyChatgptExactSubmissionTab(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  targetUrl: string,
+  timeoutMs?: number,
+): Promise<void> {
+  const observed = await controllerBrowserAction(controllerHome, workId, 'get_text', {
+    session_id: browserSessionId,
+    selector: CHATGPT_PROMPT_SELECTOR,
+    max_chars: 1,
+    timeout_ms: Math.min(timeoutMs ?? 3_000, 3_000),
+  }, timeoutMs);
+  if (!chatgptBrowserObservationMatchesTarget(observed, browserSessionId, targetUrl)) {
+    throw new ChatgptProviderDeliveryError('CHATGPT_AUTOMATION_TARGET_IDENTITY_CHANGED',
+      `CHATGPT_AUTOMATION_TARGET_IDENTITY_CHANGED:${targetUrl}`, { conversationUrl: targetUrl });
+  }
+}
+
 function completeChatgptBrowserInventorySessions(
   inventory: Record<string, unknown>,
 ): ChatgptBrowserSessionInventoryItem[] | undefined {
@@ -557,11 +878,19 @@ export async function closeChatgptAutomationTabAfterDispatch(
   workId: string,
   browserSessionId: string,
   timeoutMs?: number,
+  authorizationGrantRefs: readonly string[] = [],
 ): Promise<{ status: ChatgptAutomationTabCleanupStatus; error?: { code: string; message: string } }> {
   try {
-    const closed = await controllerBrowserAction(controllerHome, workId, 'close_page', {
+    const closePage = () => controllerBrowserAction(controllerHome, workId, 'close_page', {
       session_id: browserSessionId,
     }, Math.min(timeoutMs ?? 15_000, 15_000));
+    const closed = authorizationGrantRefs.length > 0
+      ? await withChatgptBrowserActionOrigin(
+          { surface: 'schedule', actor: 'chatgpt-work-continuation' },
+          closePage,
+          new Set(authorizationGrantRefs),
+        )
+      : await closePage();
     if (closed.preservedUserOwnedTab === true) return { status: 'preserved_user_owned' };
     if (closed.resourceClosed === true) return { status: 'closed' };
     return { status: 'session_closed' };
@@ -588,6 +917,7 @@ export async function settleWorkChatgptAutomationTab(input: {
   workId: string;
   browserSessionId: string;
   timeoutMs?: number;
+  authorizationGrantRefs?: readonly string[];
 }): Promise<{ status: ChatgptAutomationTabCleanupStatus; error?: { code: string; message: string } }> {
   if (input.browserSessionId.startsWith('forge-chatgpt-bridge-')) return { status: 'session_closed' };
   return closeChatgptAutomationTabAfterDispatch(
@@ -595,6 +925,7 @@ export async function settleWorkChatgptAutomationTab(input: {
     input.workId,
     input.browserSessionId,
     input.timeoutMs,
+    input.authorizationGrantRefs,
   );
 }
 
@@ -632,6 +963,14 @@ export async function navigateWorkConversation(
       const opened = await controllerBrowserAction(controllerHome, workId, 'create_session', {
         session_id: sessionId,
         url,
+        // Direct Browser delivery must never silently escalate to the macOS
+        // Apple Events compatibility provider. Work-bound unattended delivery is
+        // owned by Workflow Supervisor's extension transport; this legacy direct
+        // lane uses a Forge-managed browser resource unless the caller explicitly
+        // configured a different transport elsewhere.
+        browser_mode: 'managed_persistent',
+        native_attach_mode: 'disabled',
+        cdp_attach_fallback: 'fail_closed',
         wait_until: 'domcontentloaded',
         timeout_ms: timeoutMs ?? 60_000,
         retries: 1,
@@ -665,6 +1004,13 @@ export async function navigateWorkConversation(
     } catch (preflightError) {
       if (!chatgptAutomationNavigationRequiresReplacement(preflightError)) throw preflightError;
       const replacementSessionId = await openReplacement(browserSessionId, targetUrl);
+      // create_session establishes only the session capability. Activating the
+      // exact replacement page is an interaction-capability action, so an
+      // interactive prepare also establishes the grant required by later
+      // schedule-origin fill/click actions on this same origin.
+      await controllerBrowserAction(controllerHome, workId, 'activate_page', {
+        session_id: replacementSessionId,
+      }, timeoutMs);
       return { submissionTargetUrl: targetUrl, recoveredFromStaleBinding: true, browserSessionId: replacementSessionId };
     }
     await navigate(browserSessionId, targetUrl);
@@ -689,15 +1035,11 @@ export async function navigateWorkConversation(
       const replacementSessionId = await openReplacement(browserSessionId, targetUrl);
       return { submissionTargetUrl: targetUrl, recoveredFromStaleBinding: false, browserSessionId: replacementSessionId };
     }
-    if (!isChatgptConversationUrl(targetUrl)) throw error;
-    try {
-      await navigate(browserSessionId, 'https://chatgpt.com/');
-      return { submissionTargetUrl: 'https://chatgpt.com/', recoveredFromStaleBinding: true, browserSessionId };
-    } catch (fallbackError) {
-      if (!chatgptAutomationNavigationRequiresReplacement(fallbackError)) throw fallbackError;
-      const replacementSessionId = await openReplacement(browserSessionId, 'https://chatgpt.com/');
-      return { submissionTargetUrl: 'https://chatgpt.com/', recoveredFromStaleBinding: true, browserSessionId: replacementSessionId };
-    }
+    // A bound /c/<id> is transport identity, not a hint. Falling back to the
+    // ChatGPT root silently creates a replacement conversation and can turn one
+    // transient navigation failure into duplicate provider recovery. Preserve the
+    // exact conversation and let the owning continuation reconcile or retry it.
+    throw error;
   }
 }
 
@@ -709,17 +1051,62 @@ export async function submitChatgptPrompt(
   targetUrl: string,
   timeoutMs?: number,
 ): Promise<string> {
-  const renderedPrompt = withForgePluginMention(prompt);
-  const before = await latestChatgptUserMessage(controllerHome, workId, browserSessionId, timeoutMs)
-    .catch((): { selector?: string; preview: string; url?: string } => ({ selector: undefined, preview: '', url: targetUrl }));
+  // Verify the live native tab before reading/sending. The saved session may
+  // have retargeted while its Browser handle remained stable.
+  await verifyChatgptExactSubmissionTab(
+    controllerHome, workId, browserSessionId, targetUrl, timeoutMs,
+  );
+  const renderedPrompt = chatgptSupervisorPromptBody(prompt);
+  const [before, beforeAssistant, failedRequestBaseline, preexistingPageFailure] = await Promise.all([
+    latestChatgptUserMessage(controllerHome, workId, browserSessionId, timeoutMs)
+      .catch((): { selector?: string; preview: string; url?: string } => ({ selector: undefined, preview: '', url: targetUrl })),
+    latestChatgptAssistantMessage(controllerHome, workId, browserSessionId, timeoutMs)
+      .catch((): { selector?: string; preview: string } => ({ selector: undefined, preview: '' })),
+    chatgptFailedRequestBaseline(controllerHome, workId, browserSessionId, timeoutMs),
+    chatgptProviderFailureOnErrorUi(controllerHome, workId, browserSessionId, timeoutMs),
+  ]);
+  if (preexistingPageFailure === CHATGPT_AUTOMATION_RATE_LIMITED) {
+    throw new ChatgptProviderDeliveryError(
+      CHATGPT_AUTOMATION_RATE_LIMITED,
+      `${CHATGPT_AUTOMATION_RATE_LIMITED}:${targetUrl}`,
+      { conversationUrl: targetUrl },
+    );
+  }
+  const mentionTriggerDraft = `${renderedPrompt}\n@`;
   await controllerBrowserAction(controllerHome, workId, 'fill', {
     session_id: browserSessionId,
     selector: CHATGPT_PROMPT_SELECTOR,
-    text: renderedPrompt,
+    text: mentionTriggerDraft,
     timeout_ms: timeoutMs ?? 60_000,
     post_action_wait_ms: 100,
   }, timeoutMs);
 
+  // Browser fill can report success even when the live ProseMirror composer did
+  // not retain the intended payload. Never send or trigger Enter fallback on
+  // an unverified draft; the owning effect must remain unreplayed.
+  const verifiedComposerText = await currentChatgptComposerText(
+    controllerHome, workId, browserSessionId, timeoutMs,
+  );
+  if (!chatgptComposerRetainsPrompt(verifiedComposerText, mentionTriggerDraft)) {
+    throw new ChatgptProviderDeliveryError(
+      'CHATGPT_AUTOMATION_COMPOSER_UNVERIFIED',
+      `CHATGPT_AUTOMATION_COMPOSER_UNVERIFIED:${targetUrl}`,
+      { conversationUrl: targetUrl },
+    );
+  }
+
+  // The immutable effect marker alone is not enough: choose the exact main
+  // Forge app and verify its structured mention before sending the payload.
+  await bindChatgptForgePluginMention(
+    controllerHome, workId, browserSessionId, renderedPrompt, targetUrl, timeoutMs,
+  );
+
+  // A popup or plugin-selection action can change the native tab. Re-attest
+  // immediately before Send, never infer identity from a successful click.
+  await verifyChatgptExactSubmissionTab(
+    controllerHome, workId, browserSessionId, targetUrl, timeoutMs,
+  );
+
   let observedUrl = targetUrl;
   let submitOutcomeUnknown = false;
   let observedNewOutbound = false;
@@ -733,9 +1120,46 @@ export async function submitChatgptPrompt(
     observedUrl = resultUrl(sent) ?? observedUrl;
   } catch (error) {
     if (browserMutationOutcomeUnknown(error, 'click')) {
-      // Never replay an outcome-unknown submit: semantic observation below decides
-      // whether the original click committed, preventing duplicate user messages.
+      // Never blind-replay an outcome-unknown submit. First reconcile the exact
+      // provider state. If the same payload is still wholly present in the
+      // composer, no new user message exists, and no conversation identity was
+      // created, the original click is mechanically proven not to have committed.
+      // Only then may the same provider dispatch resume Send once without
+      // refilling the composer or creating a new semantic effect generation.
       submitOutcomeUnknown = true;
+      const latestAfterUnknown = await latestChatgptUserMessage(
+        controllerHome,
+        workId,
+        browserSessionId,
+        timeoutMs,
+      ).catch(() => undefined);
+      if (latestAfterUnknown) {
+        observedUrl = latestAfterUnknown.url ?? observedUrl;
+        observedNewOutbound = chatgptMessageObservationChanged(before, latestAfterUnknown);
+      }
+      const hasConversationIdentity = /\/c\/[^/?#]+/.test(observedUrl);
+      const [composerHtml, composerText] = await Promise.all([
+        currentChatgptComposerHtml(controllerHome, workId, browserSessionId, timeoutMs),
+        currentChatgptComposerText(controllerHome, workId, browserSessionId, timeoutMs),
+      ]);
+      if (
+        !observedNewOutbound
+        && !hasConversationIdentity
+        && chatgptForgePluginMentionBound(composerHtml, composerText, renderedPrompt)
+      ) {
+        try {
+          const resumed = await controllerBrowserAction(controllerHome, workId, 'click', {
+            session_id: browserSessionId,
+            selector: CHATGPT_SEND_SELECTOR,
+            timeout_ms: timeoutMs ?? 60_000,
+            post_action_wait_ms: 250,
+          }, timeoutMs);
+          observedUrl = resultUrl(resumed) ?? observedUrl;
+          submitOutcomeUnknown = false;
+        } catch (resumeError) {
+          if (!browserMutationOutcomeUnknown(resumeError, 'click')) throw resumeError;
+        }
+      }
     } else if (chatgptSendControlUnavailable(error)) {
       const pressed = await controllerBrowserAction(controllerHome, workId, 'press', {
         session_id: browserSessionId,
@@ -750,28 +1174,78 @@ export async function submitChatgptPrompt(
     }
   }
 
-  const deadline = Date.now() + Math.min(Math.max(timeoutMs ?? 10_000, 3_000), 10_000);
+  const deadline = Date.now() + chatgptSubmissionSettlementWaitBudget(timeoutMs);
+  let nextFailureProbeAt = 0;
+  let observationIndex = 0;
   do {
     const latest = await latestChatgptUserMessage(controllerHome, workId, browserSessionId, timeoutMs).catch(() => undefined);
     if (latest) {
       observedUrl = latest.url ?? observedUrl;
-      const isNewOutbound = Boolean(
-        (latest.selector && latest.selector !== before.selector)
-        || (!before.preview && latest.preview)
-        || latest.preview !== before.preview,
-      );
+      const isNewOutbound = chatgptMessageObservationChanged(before, latest);
       if (isNewOutbound) {
         observedNewOutbound = true;
         const fullText = await fullChatgptMessageText(controllerHome, workId, browserSessionId, latest, timeoutMs);
-        if (chatgptOutboundMessageMatchesPrompt(fullText.text, renderedPrompt, { truncated: fullText.truncated }) && /\/c\/[^/?#]+/.test(observedUrl)) {
-          return observedUrl;
+        const outboundConfirmed = chatgptOutboundMessageMatchesPrompt(fullText.text, renderedPrompt, { truncated: fullText.truncated, boundForgePlugin: true });
+        const hasConversationIdentity = /\/c\/[^/?#]+/.test(observedUrl);
+        if (outboundConfirmed && hasConversationIdentity) {
+          const [latestAssistant, generationInProgress] = await Promise.all([
+            latestChatgptAssistantMessage(controllerHome, workId, browserSessionId, timeoutMs).catch(() => undefined),
+            chatgptGenerationInProgress(controllerHome, workId, browserSessionId, timeoutMs),
+          ]);
+          const assistantResponseObserved = Boolean(
+            latestAssistant?.preview
+            && chatgptMessageObservationChanged(beforeAssistant, latestAssistant),
+          );
+          if (chatgptSubmissionAcceptanceObserved({
+            outboundConfirmed,
+            hasConversationIdentity,
+            assistantResponseObserved,
+            generationInProgress,
+          })) {
+            return observedUrl;
+          }
+          if (Date.now() >= nextFailureProbeAt) {
+            const deliveryFailure = await chatgptDeliveryFailureOnPage(
+              controllerHome,
+              workId,
+              browserSessionId,
+              failedRequestBaseline,
+              timeoutMs,
+            );
+            if (deliveryFailure) {
+              const failureCode = deliveryFailure === CHATGPT_AUTOMATION_RATE_LIMITED
+                ? CHATGPT_AUTOMATION_RATE_LIMITED_AFTER_SUBMIT
+                : deliveryFailure;
+              throw new ChatgptProviderDeliveryError(
+                failureCode,
+                `${failureCode}:${observedUrl}`,
+                { conversationUrl: observedUrl },
+              );
+            }
+            nextFailureProbeAt = Date.now() + CHATGPT_DELIVERY_FAILURE_PROBE_INTERVAL_MS;
+          }
         }
       }
     }
-    await new Promise((resolveWait) => setTimeout(resolveWait, 150));
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) break;
+    const observationDelayMs = chatgptSubmissionObservationDelayMs(observationIndex);
+    observationIndex += 1;
+    await new Promise((resolveWait) => setTimeout(resolveWait, Math.min(observationDelayMs, remainingMs)));
   } while (Date.now() < deadline);
   const hasConversationIdentity = /\/c\/[^/?#]+/.test(observedUrl);
-  const failureCode = submitOutcomeUnknown || (observedNewOutbound && hasConversationIdentity)
+  const finalComposerText = submitOutcomeUnknown && !observedNewOutbound && !hasConversationIdentity
+    ? await currentChatgptComposerText(controllerHome, workId, browserSessionId, timeoutMs)
+    : undefined;
+  const submitProvablyNotApplied = submitOutcomeUnknown
+    && !observedNewOutbound
+    && !hasConversationIdentity
+    && chatgptComposerRetainsPrompt(finalComposerText, renderedPrompt);
+  // A fresh /c/<id> or any changed outbound user message is provider-side
+  // evidence that the send may have committed even when DOM observation lagged.
+  // Keep that ambiguity fenced. Conversely, an exact unchanged composer proves
+  // the send did not commit and must not be mislabeled outcome_unknown.
+  const failureCode = (submitOutcomeUnknown && !submitProvablyNotApplied) || hasConversationIdentity || observedNewOutbound
     ? CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN
     : 'CHATGPT_AUTOMATION_SUBMISSION_NOT_CONFIRMED';
   throw new ChatgptProviderDeliveryError(
@@ -780,4 +1254,3 @@ export async function submitChatgptPrompt(
     { conversationUrl: observedUrl },
   );
 }
-