@moretea-labs/forge 1.7.1 → 1.8.0

package/src/runtime/control-plane/launcher/chatgpt-work-continuation.ts

@@ -1,7 +1,28 @@
 import { createHash, randomUUID } from 'crypto';
-import { buildBrowserPluginManifest, executeBrowserPluginAction } from '../../plugins/browser-adapter';
-import { controllerPluginRepository } from '../../plugins/store';
-import { getWorkContract } from '../facade/work-contract-store';
+import { isWslWindowsRuntime } from '../../../cli/chatgpt-browser/bridge-provider';
+import { createChatgptBrowserDeliveryHost } from '../../../../adapters/chatgpt/browser-delivery-host';
+import { createChatgptWslBridgeDeliveryHost } from '../../../../adapters/chatgpt/wsl-bridge-delivery-host';
+import {
+  CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN,
+  DEFAULT_CHATGPT_AUTOMATION_MODEL,
+  DEFAULT_CHATGPT_AUTOMATION_REASONING,
+  DEFAULT_CHATGPT_AUTOMATION_TAB_POLICY,
+  type ChatgptAutomationReasoning,
+  type ChatgptAutomationTabCleanupStatus,
+  type ChatgptAutomationTabPolicy,
+  type ChatgptProviderDeliveryHost,
+  type ChatgptProviderDeliveryStatus,
+} from '../../../../adapters/chatgpt/provider-delivery';
+import {
+  closeChatgptAutomationTabAfterDispatch,
+  ensureChatgptExecutionPreference,
+  ensureControllerChatgptBrowser,
+  navigateWorkConversation,
+  submitChatgptPrompt,
+  withChatgptBrowserActionOrigin,
+} from '../../../../adapters/chatgpt/browser-delivery-runtime';
+import { getWorkContract } from '../../../../packages/kernel/work/api/index';
+import { readForgeInstanceIdentity } from '../../../../packages/kernel/identity/api/index';
 import {
   bindChatgptWorkConversation,
   getChatgptWorkConversationBinding,
@@ -9,25 +30,48 @@ import {
   parseChatgptConversationIdentity,
   rebindChatgptWorkConversation,
   type ChatgptWorkConversationBinding,
-} from './chatgpt-work-binding-store';
+} from '../../../../adapters/chatgpt/work-conversation-binding-store';
+
+export {
+  CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN,
+  DEFAULT_CHATGPT_AUTOMATION_MODEL,
+  DEFAULT_CHATGPT_AUTOMATION_REASONING,
+  DEFAULT_CHATGPT_AUTOMATION_TAB_POLICY,
+  type ChatgptAutomationReasoning,
+  type ChatgptAutomationTabCleanupStatus,
+  type ChatgptAutomationTabPolicy,
+  type ChatgptProviderDeliveryStatus,
+} from '../../../../adapters/chatgpt/provider-delivery';
+export {
+  chatgptAutomationControlQueryLimit,
+  chatgptAutomationControlWaitBudgets,
+  chatgptAutomationNavigationRequiresReplacement,
+  chatgptAutomationPageFailure,
+  chatgptAutomationReasoningLevelFromLabel,
+  chatgptBrowserActionArgs,
+  chatgptBrowserActionResult,
+  chatgptOutboundMessageMatchesPrompt,
+  isChatgptConversationUrl,
+  reconciledNewChatgptOpenPageSessionId,
+  settleWorkChatgptAutomationTab,
+} from '../../../../adapters/chatgpt/browser-delivery-runtime';
 
 const LEGACY_CONTROLLER_CHATGPT_SESSION_ID = 'forge-chatgpt-supercontroller';
-export const DEFAULT_CHATGPT_AUTOMATION_MODEL = 'gpt-5.6';
-export const DEFAULT_CHATGPT_AUTOMATION_REASONING = 'high';
-export const DEFAULT_CHATGPT_AUTOMATION_TAB_POLICY = 'auto';
 export const DEFAULT_CHATGPT_AUTOMATION_PLUGIN_MENTION = '@forge';
-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_INTELLIGENCE_CONTROL_SELECTORS = [
-  'main button, main [role="button"]',
-  'button, [role="button"]',
-] as const;
-const CHATGPT_CAPABILITY_SLIDER_SELECTOR = '[role="slider"]';
-const CHATGPT_CAPABILITY_MENUITEM_SELECTOR = '[role="menuitem"][aria-keyshortcuts~="ArrowLeft"][aria-keyshortcuts~="ArrowRight"]';
 
-export type ChatgptAutomationReasoning = 'medium' | 'high' | 'xhigh';
-export type ChatgptAutomationTabPolicy = 'auto' | 'reuse' | 'new';
-export type ChatgptAutomationTabCleanupStatus = 'closed' | 'preserved_user_owned' | 'session_closed' | 'failed';
+export class ChatgptExecutionPlacementError extends Error {
+  readonly code = 'CHATGPT_EXECUTION_PLACEMENT_MISMATCH';
+  readonly targetForgeInstanceId: string;
+  readonly currentForgeInstanceId?: string;
+
+  constructor(targetForgeInstanceId: string, currentForgeInstanceId?: string) {
+    super(`CHATGPT_EXECUTION_PLACEMENT_MISMATCH: target=${targetForgeInstanceId} current=${currentForgeInstanceId ?? 'unavailable'}`);
+    this.name = 'ChatgptExecutionPlacementError';
+    this.targetForgeInstanceId = targetForgeInstanceId;
+    this.currentForgeInstanceId = currentForgeInstanceId;
+  }
+}
+
 
 export interface WorkChatgptContinuationInput {
   controllerHome: string;
@@ -35,18 +79,34 @@ export interface WorkChatgptContinuationInput {
   repoRoot: string;
   workId: string;
   prompt: string;
+  /** Durable per-round capability minted before ChatGPT dispatch. */
+  controllerAuthorityId?: string;
+  /** Durable semantic relay scope paired with controllerAuthorityId. */
+  relayScopeId?: string;
   title?: string;
   browserSessionId?: string;
   conversationUrl?: string;
   model?: string;
   reasoning?: ChatgptAutomationReasoning;
   tabPolicy?: ChatgptAutomationTabPolicy;
+  /** Transport-only conversation policy. `fresh` starts a new ChatGPT conversation while preserving the same durable Work/ControllerRound authority. */
+  transportConversation?: 'bound' | 'fresh';
   timeoutMs?: number;
+  /** Authorization provenance for Browser actions. Immediate/source launches default to chatgpt-action; Scheduler resume must pass schedule. */
+  originSurface?: 'chatgpt-action' | 'schedule';
+  /** Explicit controller-scoped Browser grant refs already authorized for this Work transport. */
+  authorizationGrantRefs?: readonly string[];
+}
+
+export interface WorkChatgptContinuationDependencies {
+  bridgeRuntime?: boolean;
+  browserHost?: ChatgptProviderDeliveryHost;
+  wslHost?: ChatgptProviderDeliveryHost;
 }
 
 export interface WorkChatgptContinuationResult {
   status: 'dispatched' | 'failed';
-  provider: 'controller-browser';
+  provider: 'controller-browser' | 'chatgpt-bridge';
   browserSessionId: string;
   conversationUrl?: string;
   conversationId?: string;
@@ -56,6 +116,9 @@ export interface WorkChatgptContinuationResult {
   reasoning: ChatgptAutomationReasoning;
   tabPolicy: ChatgptAutomationTabPolicy;
   executionPreferenceVerified: boolean;
+  authorizationGrantRefs?: string[];
+  /** Typed provider delivery disposition. Present when provider dispatch was attempted; callers must not infer this from error strings. */
+  providerDeliveryStatus?: ChatgptProviderDeliveryStatus;
   tabCleanupStatus?: ChatgptAutomationTabCleanupStatus;
   tabCleanupError?: { code: string; message: string };
   error?: { code: string; message: string };
@@ -64,6 +127,8 @@ export interface WorkChatgptContinuationResult {
 export interface StandaloneChatgptPromptInput {
   controllerHome: string;
   repoId: string;
+  /** Optional transport context only; current browser/bridge hosts do not derive semantic authority from this path. */
+  repoRoot?: string;
   scopeId: string;
   prompt: string;
   browserSessionId?: string;
@@ -74,61 +139,25 @@ export interface StandaloneChatgptPromptInput {
   timeoutMs?: number;
 }
 
-const workflowToolAttributionInstruction = (workId: string): string => `Forge Workflow execution contract: first claim exact Work ${workId}. For every repository_command_execute and repository_safe_patch_apply call in this turn, pass work_id=${workId} explicitly. MCP transport sessions may change between tool calls; never omit this Work id.`;
-
-function requestId(workId: string, actionId: string): string {
-  return `chatgpt-work:${workId}:${actionId}:${randomUUID()}`;
-}
-
-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 };
-}
-
-async function controllerBrowserAction(
-  controllerHome: string,
-  workId: string,
-  actionId: string,
-  args: Record<string, unknown>,
-  timeoutMs?: number,
-): Promise<Record<string, unknown>> {
-  const repository = controllerPluginRepository(controllerHome);
-  const repoRoot = repository.canonicalRoot ?? repository.localRoot;
-  if (!repoRoot) throw new Error('CHATGPT_CONTROLLER_BROWSER_ROOT_UNAVAILABLE');
-  return executeBrowserPluginAction({
-    controllerHome,
-    repoId: repository.repoId,
-    repoRoot,
-    pluginId: 'browser',
-    actionId,
-    requestId: requestId(workId, actionId),
-    args: chatgptBrowserActionArgs(actionId, args),
-    timeoutMs,
-    origin: { surface: 'schedule', actor: 'chatgpt-work-continuation' },
-  });
-}
-
-async function ensureControllerChatgptBrowser(controllerHome: string, workId: string): Promise<void> {
-  const repository = controllerPluginRepository(controllerHome);
-  const repoRoot = repository.canonicalRoot ?? repository.localRoot;
-  if (!repoRoot) throw new Error('CHATGPT_CONTROLLER_BROWSER_ROOT_UNAVAILABLE');
-  // Browser configure is not a read: it persists configuration and closes managed
-  // contexts. Scheduled continuations must not disturb an already-enabled provider
-  // merely to prove it is available. Only enable it when the persisted authority is
-  // explicitly disabled; action-level transport overrides still fail closed later.
-  if (buildBrowserPluginManifest(0, undefined, repoRoot).enabled) return;
-  await controllerBrowserAction(controllerHome, workId, 'configure', { enabled: true });
+function workflowToolAttributionInstruction(input: WorkChatgptContinuationInput): string {
+  const workId = input.workId;
+  const authorityId = input.controllerAuthorityId?.trim();
+  const relayScopeId = input.relayScopeId?.trim();
+  const requirementScoped = relayScopeId?.startsWith('requirement:') === true;
+  const repositoryAttribution = requirementScoped
+    ? `本轮普通 repository_command_execute 和 repository_safe_patch_apply 必须显式传入实际被本轮语义选择且已成功 claim 的 repository-change Work 的 work_id；如果仍在推进 origin Work，则使用 work_id=${workId}。不得把只读/编排 Supervisor Work 的 work_id 用来归属 child Work 的源码修改，也不得省略 work_id。`
+    : `本轮每一次 repository_command_execute 和 repository_safe_patch_apply 都必须显式传 work_id=${workId}，不得省略。`;
+  if (authorityId && relayScopeId) {
+    return `Forge Workflow 执行契约：精确 Work ${workId}。本次启动的 controller round 已具备 durable controller authority：controller_authority_id=${authorityId}，relay_scope_id=${relayScopeId}。第一次 controller_claim 必须使用这组完全相同的 authority；不得先调用不带 scope 的 controller_claim，也不得等待 claim 响应后再生成另一份 authority。如果当前 client 暴露 controller_authority_id 与 relay_scope_id，controller_claim 时必须同时传入。如果当前 frozen client schema 缺少任一字段，调用 rh_work operation=repair, work_id=${workId}, capability_id=controller.round:controller_claim:${authorityId}:${relayScopeId}；Forge 会把它映射到同一个 fenced claim。claim 成功后，data.controllerAuthorityId 必须等于 ${authorityId}；continue、verify、finalize、stop、controller_release 必须原样沿用同一 durable authority，必要时使用对应 compatibility capability。绝不能把 data.session.sessionId 当作 durable capability，因为 MCP execution session 可能轮换。${repositoryAttribution}唯一例外是 prompt 明确标记为 exact current-source Controller lifecycle invocation 的 repository_command_execute，它必须使用给定 source checkout_id 且不得传 wrapper work_id，因为 CLI 内部 --work-id 与 ControllerRound authority 才是该控制面变更的 fenced authority。`;
+  }
+  return `Forge Workflow 执行契约：首先 claim 精确 Work ${workId}。从成功的 controller_claim 响应中取得 data.controllerAuthorityId；此后该 Work 的每一次 rh_work lifecycle 调用（continue、verify、finalize、stop、controller_release）都必须把它原样作为 controller_authority_id 传入。如果当前 frozen client schema 不暴露 controller_authority_id，则把同一个 opaque value 作为 session_id compatibility carrier。绝不能把 data.session.sessionId 当作 durable capability，因为 MCP execution session 可能在工具调用之间被替换或失效。本轮每一次 repository_command_execute 和 repository_safe_patch_apply 都必须显式传 work_id=${workId}，不得省略；唯一例外是 prompt 明确标记为 exact current-source Controller lifecycle invocation 的 repository_command_execute，它必须使用给定 source checkout_id 且不得传 wrapper work_id，因为 CLI 内部 --work-id 与 ControllerRound authority 才是该控制面变更的 fenced authority。`;
 }
 
-function stringField(value: unknown): string | undefined {
-  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+function controllerRoundAuthorityInputError(input: WorkChatgptContinuationInput): Error | undefined {
+  const hasAuthority = Boolean(input.controllerAuthorityId?.trim());
+  const hasRelayScope = Boolean(input.relayScopeId?.trim());
+  if (hasAuthority === hasRelayScope) return undefined;
+  return new Error('CHATGPT_CONTROLLER_ROUND_AUTHORITY_INCOMPLETE: controllerAuthorityId and relayScopeId must be supplied together');
 }
 
 function normalizeModel(value?: string): string {
@@ -141,15 +170,41 @@ function normalizeReasoning(value?: ChatgptAutomationReasoning): ChatgptAutomati
   return value ?? DEFAULT_CHATGPT_AUTOMATION_REASONING;
 }
 
+const DEFAULT_CHATGPT_CONTROLLER_REASONING: ChatgptAutomationReasoning = 'xhigh';
+
+function normalizeControllerReasoning(value?: ChatgptAutomationReasoning): ChatgptAutomationReasoning {
+  return value ?? DEFAULT_CHATGPT_CONTROLLER_REASONING;
+}
+
 function normalizeTabPolicy(value?: ChatgptAutomationTabPolicy): ChatgptAutomationTabPolicy {
   return value ?? DEFAULT_CHATGPT_AUTOMATION_TAB_POLICY;
 }
 
+function resolveChatgptProviderDeliveryHost(
+  dependencies: WorkChatgptContinuationDependencies = {},
+): { bridgeRuntime: boolean; host: ChatgptProviderDeliveryHost } {
+  const bridgeRuntime = dependencies.bridgeRuntime ?? isWslWindowsRuntime();
+  const host = bridgeRuntime
+    ? dependencies.wslHost ?? createChatgptWslBridgeDeliveryHost()
+    : dependencies.browserHost ?? createChatgptBrowserDeliveryHost({
+        ensureBrowser: ensureControllerChatgptBrowser,
+        navigate: navigateWorkConversation,
+        ensureExecutionPreference: ensureChatgptExecutionPreference,
+        submitPrompt: submitChatgptPrompt,
+      });
+  return { bridgeRuntime, host };
+}
+
 export function stableChatgptWorkBrowserSessionId(repoId: string, workId: string): string {
   const digest = createHash('sha256').update(`${repoId}\n${workId}`).digest('hex').slice(0, 20);
   return `forge-chatgpt-work-${digest}`;
 }
 
+export function stableChatgptWorkBridgeSessionId(repoId: string, workId: string): string {
+  const digest = createHash('sha256').update(`${repoId}\nbridge\n${workId}`).digest('hex').slice(0, 20);
+  return `forge-chatgpt-bridge-${digest}`;
+}
+
 export function stableStandaloneChatgptBrowserSessionId(repoId: string, scopeId: string): string {
   const digest = createHash('sha256').update(`${repoId}\nstandalone\n${scopeId}`).digest('hex').slice(0, 20);
   return `forge-chatgpt-standalone-${digest}`;
@@ -179,411 +234,6 @@ export function resolveChatgptWorkBrowserSessionId(input: {
   return stable;
 }
 
-interface BrowserQueryMatch {
-  text?: string;
-  selectorHint?: string;
-}
-
-function queryMatches(result: Record<string, unknown> | undefined): BrowserQueryMatch[] {
-  if (!result || !Array.isArray(result.matches)) return [];
-  return result.matches.filter((value): value is BrowserQueryMatch => Boolean(value) && typeof value === 'object');
-}
-
-function matchText(value: BrowserQueryMatch): string {
-  return typeof value.text === 'string' ? value.text.trim() : '';
-}
-
-function matchSelector(value: BrowserQueryMatch | undefined): string | undefined {
-  return typeof value?.selectorHint === 'string' && value.selectorHint.trim() ? value.selectorHint.trim() : undefined;
-}
-
-function normalizeExecutionControlLabel(label: string | undefined): string {
-  return (label ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '');
-}
-
-export function chatgptAutomationReasoningLevelFromLabel(label: string | undefined): ChatgptAutomationReasoning | undefined {
-  const normalized = normalizeExecutionControlLabel(label);
-  if (!normalized) return undefined;
-
-  const exact = new Map<string, ChatgptAutomationReasoning>([
-    ['medium', 'medium'], ['中', 'medium'], ['中等', 'medium'],
-    ['high', 'high'], ['高', 'high'],
-    ['xhigh', 'xhigh'], ['extrahigh', 'xhigh'], ['超高', 'xhigh'], ['极高', 'xhigh'],
-  ]);
-  const exactLevel = exact.get(normalized);
-  if (exactLevel) return exactLevel;
-
-  const hasReasoningContext = ['reasoning', 'thinking', '推理', '思考']
-    .some((token) => normalized.includes(token));
-  if (!hasReasoningContext) return undefined;
-  if (['xhigh', 'extrahigh', '超高', '极高'].some((token) => normalized.includes(token))) return 'xhigh';
-  if (['medium', '中等'].some((token) => normalized.includes(token))) return 'medium';
-  if (['high', '高'].some((token) => normalized.includes(token))) return 'high';
-  return undefined;
-}
-
-function modelLabelMatches(label: string | undefined, model: string): boolean {
-  if (model !== DEFAULT_CHATGPT_AUTOMATION_MODEL || !label) return false;
-  const normalized = normalizeExecutionControlLabel(label);
-  return normalized.includes('5.6sol') || normalized.includes('gpt5.6sol');
-}
-
-function reasoningLabelMatches(label: string | undefined, reasoning: ChatgptAutomationReasoning): boolean {
-  return chatgptAutomationReasoningLevelFromLabel(label) === reasoning;
-}
-
-function isReasoningControlLabel(label: string | undefined): boolean {
-  return reasoningLabelMatches(label, 'medium')
-    || reasoningLabelMatches(label, 'high')
-    || reasoningLabelMatches(label, 'xhigh');
-}
-
-function reasoningSliderValue(reasoning: ChatgptAutomationReasoning): number {
-  if (reasoning === 'medium') return 2;
-  if (reasoning === 'high') return 3;
-  return 4;
-}
-
-async function findChatgptIntelligenceControl(
-  controllerHome: string,
-  workId: string,
-  browserSessionId: string,
-  timeoutMs?: number,
-): Promise<BrowserQueryMatch | undefined> {
-  for (const selector of CHATGPT_INTELLIGENCE_CONTROL_SELECTORS) {
-    const result = await controllerBrowserAction(controllerHome, workId, 'query_all', {
-      session_id: browserSessionId,
-      selector,
-      // Prefer the composer/main region so sidebar history cannot crowd the
-      // reasoning control out of a bounded query. Keep a larger global fallback
-      // for ChatGPT layouts that place the control outside <main>.
-      limit: chatgptAutomationControlQueryLimit(selector),
-      timeout_ms: timeoutMs ?? 60_000,
-    }, timeoutMs);
-    const match = queryMatches(result).find((candidate) => {
-      const label = matchText(candidate);
-      return modelLabelMatches(label, DEFAULT_CHATGPT_AUTOMATION_MODEL) || isReasoningControlLabel(label);
-    });
-    if (match) return match;
-  }
-  return undefined;
-}
-
-export function chatgptAutomationControlQueryLimit(selector: string): number {
-  // Long tool-heavy conversations can contribute well over 80 buttons before
-  // the composer controls. Keep the preferred <main> scan bounded but large
-  // enough that the current reasoning control is not crowded out by history.
-  return selector.startsWith('main ') ? 160 : 320;
-}
-
-export function chatgptAutomationControlWaitBudgets(timeoutMs?: number): { waitBudgetMs: number; probeTimeoutMs: number } {
-  const waitBudgetMs = Math.min(Math.max(timeoutMs ?? 30_000, 1_000), 30_000);
-  // Native Chrome attachment has a few seconds of Apple Events/DOM latency on
-  // long conversations. Keep each probe bounded while allowing a real query to
-  // complete; the total readiness window remains capped at 30 seconds.
-  return { waitBudgetMs, probeTimeoutMs: Math.min(waitBudgetMs, 5_000) };
-}
-
-async function waitForChatgptIntelligenceControl(
-  controllerHome: string,
-  workId: string,
-  browserSessionId: string,
-  timeoutMs?: number,
-): Promise<BrowserQueryMatch | undefined> {
-  const { waitBudgetMs, probeTimeoutMs } = chatgptAutomationControlWaitBudgets(timeoutMs);
-  const deadline = Date.now() + waitBudgetMs;
-  do {
-    const control = await findChatgptIntelligenceControl(controllerHome, workId, browserSessionId, probeTimeoutMs);
-    if (control) return control;
-    if (Date.now() >= deadline) break;
-    await new Promise((resolveWait) => setTimeout(resolveWait, 500));
-  } while (Date.now() < deadline);
-  return undefined;
-}
-
-export function chatgptAutomationPageFailure(
-  bodyText: string | undefined,
-  composerAvailable: boolean,
-): 'CHATGPT_AUTOMATION_LOGIN_REQUIRED' | 'CHATGPT_AUTOMATION_COMPOSER_UNAVAILABLE' | undefined {
-  if (composerAvailable) return undefined;
-  const normalized = (bodyText ?? '').toLowerCase();
-  const loginMarkers = [
-    'log in', 'sign up', 'continue with google', 'continue with apple',
-    '登录', '登陆', '注册', '使用 google 继续', '使用 apple 继续',
-  ];
-  return loginMarkers.some((marker) => normalized.includes(marker))
-    ? 'CHATGPT_AUTOMATION_LOGIN_REQUIRED'
-    : 'CHATGPT_AUTOMATION_COMPOSER_UNAVAILABLE';
-}
-
-async function assertChatgptAutomationComposerReady(
-  controllerHome: string,
-  workId: string,
-  browserSessionId: string,
-  timeoutMs?: number,
-): Promise<void> {
-  const composerResult = await controllerBrowserAction(controllerHome, workId, 'query_all', {
-    session_id: browserSessionId,
-    selector: CHATGPT_PROMPT_SELECTOR,
-    limit: 1,
-    timeout_ms: Math.min(timeoutMs ?? 5_000, 5_000),
-  }, timeoutMs).catch(() => undefined);
-  const composerAvailable = queryMatches(composerResult).length > 0;
-  if (composerAvailable) return;
-
-  const bodyResult = await controllerBrowserAction(controllerHome, workId, 'get_text', {
-    session_id: browserSessionId,
-    selector: 'body',
-    max_chars: 4_000,
-    timeout_ms: Math.min(timeoutMs ?? 5_000, 5_000),
-  }, timeoutMs).catch(() => undefined);
-  const failure = chatgptAutomationPageFailure(stringField(bodyResult?.text), composerAvailable);
-  throw new Error(failure ?? 'CHATGPT_AUTOMATION_COMPOSER_UNAVAILABLE');
-}
-
-async function ensureChatgptExecutionPreference(
-  controllerHome: string,
-  workId: string,
-  browserSessionId: string,
-  model: string,
-  reasoning: ChatgptAutomationReasoning,
-  timeoutMs?: number,
-): Promise<boolean> {
-  if (model !== DEFAULT_CHATGPT_AUTOMATION_MODEL) throw new Error(`CHATGPT_AUTOMATION_MODEL_UNSUPPORTED:${model}`);
-  let control = await waitForChatgptIntelligenceControl(controllerHome, workId, browserSessionId, timeoutMs);
-  if (!control) {
-    await assertChatgptAutomationComposerReady(controllerHome, workId, browserSessionId, timeoutMs);
-    throw new Error('CHATGPT_AUTOMATION_INTELLIGENCE_CONTROL_UNAVAILABLE');
-  }
-  // Current ChatGPT UI exposes the reasoning level (for example `高`) on the
-  // composer control instead of the model label. The model remains fail-closed
-  // through normalizeModel above; only the user-adjustable reasoning control is
-  // required to be observable in the page before unattended dispatch proceeds.
-  if (reasoningLabelMatches(matchText(control), reasoning)) return true;
-  let controlSelector = matchSelector(control);
-  if (!controlSelector) throw new Error('CHATGPT_AUTOMATION_INTELLIGENCE_CONTROL_UNAVAILABLE');
-
-  const expanded = await controllerBrowserAction(controllerHome, workId, 'get_attribute', {
-    session_id: browserSessionId,
-    selector: controlSelector,
-    attribute: 'aria-expanded',
-    timeout_ms: timeoutMs ?? 60_000,
-  }, timeoutMs).catch(() => undefined);
-  if (stringField(expanded?.value) !== 'true') {
-    await controllerBrowserAction(controllerHome, workId, 'press', {
-      session_id: browserSessionId,
-      selector: controlSelector,
-      key: 'ArrowDown',
-      timeout_ms: timeoutMs ?? 60_000,
-      post_action_wait_ms: 150,
-    }, timeoutMs);
-  }
-
-  const currentValueResult = await controllerBrowserAction(controllerHome, workId, 'get_attribute', {
-    session_id: browserSessionId,
-    selector: CHATGPT_CAPABILITY_SLIDER_SELECTOR,
-    attribute: 'aria-valuenow',
-    timeout_ms: timeoutMs ?? 60_000,
-  }, timeoutMs).catch(() => undefined);
-  const currentValue = Number(stringField(currentValueResult?.value));
-  const targetValue = reasoningSliderValue(reasoning);
-  if (!Number.isInteger(currentValue) || currentValue < 0 || currentValue > 4) {
-    throw new Error(`CHATGPT_AUTOMATION_REASONING_STATE_UNAVAILABLE:${reasoning}`);
-  }
-  const direction = targetValue > currentValue ? 'ArrowRight' : 'ArrowLeft';
-  for (let index = 0; index < Math.abs(targetValue - currentValue); index += 1) {
-    await controllerBrowserAction(controllerHome, workId, 'press', {
-      session_id: browserSessionId,
-      selector: CHATGPT_CAPABILITY_MENUITEM_SELECTOR,
-      key: direction,
-      timeout_ms: timeoutMs ?? 60_000,
-      post_action_wait_ms: 120,
-    }, timeoutMs);
-  }
-
-  const verifiedValueResult = await controllerBrowserAction(controllerHome, workId, 'get_attribute', {
-    session_id: browserSessionId,
-    selector: CHATGPT_CAPABILITY_SLIDER_SELECTOR,
-    attribute: 'aria-valuenow',
-    timeout_ms: timeoutMs ?? 60_000,
-  }, timeoutMs).catch(() => undefined);
-  if (Number(stringField(verifiedValueResult?.value)) !== targetValue) {
-    throw new Error(`CHATGPT_AUTOMATION_REASONING_NOT_VERIFIED:${reasoning}`);
-  }
-  control = await findChatgptIntelligenceControl(controllerHome, workId, browserSessionId, timeoutMs) ?? control;
-  if (isReasoningControlLabel(matchText(control)) && !reasoningLabelMatches(matchText(control), reasoning)) {
-    throw new Error(`CHATGPT_AUTOMATION_REASONING_NOT_VERIFIED:${reasoning}`);
-  }
-  controlSelector = matchSelector(control) ?? controlSelector;
-  await controllerBrowserAction(controllerHome, workId, 'press', {
-    session_id: browserSessionId,
-    selector: controlSelector,
-    key: 'Escape',
-    timeout_ms: timeoutMs ?? 60_000,
-    post_action_wait_ms: 100,
-  }, timeoutMs).catch(() => undefined);
-  return true;
-}
-
-function resultUrl(result: Record<string, unknown>): string | undefined {
-  return stringField(result.url)
-    ?? stringField((result.session as Record<string, unknown> | undefined)?.url);
-}
-
-function resultSessionId(result: Record<string, unknown>): string | undefined {
-  return stringField(result.session_id)
-    ?? stringField((result.session as Record<string, unknown> | undefined)?.sessionId);
-}
-
-export function chatgptAutomationNavigationRequiresReplacement(error: unknown): boolean {
-  if (!(error instanceof Error)) return false;
-  return [
-    'BROWSER_AUTOMATION_BACKGROUND_NAVIGATION_REQUIRES_REPLACEMENT',
-    'PLUGIN_BROWSER_SESSION_STATE_LOST',
-    'PLUGIN_SESSION_NOT_FOUND',
-    'PLUGIN_BROWSER_NATIVE_TAB_IDENTITY_UNPROVEN',
-  ].some((marker) => error.message.includes(marker));
-}
-
-async function closeChatgptAutomationTabAfterDispatch(
-  controllerHome: string,
-  workId: string,
-  browserSessionId: string,
-  timeoutMs?: number,
-): Promise<{ status: ChatgptAutomationTabCleanupStatus; error?: { code: string; message: string } }> {
-  try {
-    const closed = await controllerBrowserAction(controllerHome, workId, 'close_page', {
-      session_id: browserSessionId,
-    }, Math.min(timeoutMs ?? 15_000, 15_000));
-    if (closed.preservedUserOwnedTab === true) return { status: 'preserved_user_owned' };
-    if (closed.resourceClosed === true) return { status: 'closed' };
-    return { status: 'session_closed' };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      status: 'failed',
-      error: {
-        code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : 'CHATGPT_AUTOMATION_TAB_CLEANUP_FAILED',
-        message,
-      },
-    };
-  }
-}
-
-/**
- * Settles the browser resource for one completed Work-bound ChatGPT round.
- * Conversation identity is durable in the Work binding and intentionally
- * survives this ephemeral tab/session cleanup. Browser ownership policy keeps
- * user-owned native tabs intact.
- */
-export async function settleWorkChatgptAutomationTab(input: {
-  controllerHome: string;
-  workId: string;
-  browserSessionId: string;
-  timeoutMs?: number;
-}): Promise<{ status: ChatgptAutomationTabCleanupStatus; error?: { code: string; message: string } }> {
-  return closeChatgptAutomationTabAfterDispatch(
-    input.controllerHome,
-    input.workId,
-    input.browserSessionId,
-    input.timeoutMs,
-  );
-}
-
-export function isChatgptConversationUrl(value: string): boolean {
-  try {
-    const url = new URL(value);
-    return url.protocol === 'https:'
-      && ['chatgpt.com', 'www.chatgpt.com', 'chat.openai.com'].includes(url.hostname)
-      && /\/c\/[^/?#]+/.test(url.pathname);
-  } catch {
-    return false;
-  }
-}
-
-async function navigateWorkConversation(
-  controllerHome: string,
-  workId: string,
-  browserSessionId: string,
-  targetUrl: string,
-  timeoutMs?: number,
-): Promise<{ submissionTargetUrl: string; recoveredFromStaleBinding: boolean; browserSessionId: string }> {
-  const navigate = async (sessionId: string, url: string) => controllerBrowserAction(controllerHome, workId, 'navigate', {
-    session_id: sessionId,
-    url,
-    wait_until: 'domcontentloaded',
-    timeout_ms: timeoutMs ?? 60_000,
-    retries: 1,
-  }, timeoutMs);
-  const openReplacement = async (url: string): Promise<string> => {
-    const opened = await controllerBrowserAction(controllerHome, workId, 'open_page', {
-      url,
-      wait_until: 'domcontentloaded',
-      timeout_ms: timeoutMs ?? 60_000,
-      retries: 1,
-    }, timeoutMs);
-    const replacementSessionId = resultSessionId(opened);
-    if (!replacementSessionId) throw new Error('CHATGPT_AUTOMATION_REPLACEMENT_SESSION_NOT_CONFIRMED');
-    return replacementSessionId;
-  };
-  try {
-    await navigate(browserSessionId, targetUrl);
-    return { submissionTargetUrl: targetUrl, recoveredFromStaleBinding: false, browserSessionId };
-  } catch (error) {
-    if (chatgptAutomationNavigationRequiresReplacement(error)) {
-      const replacementSessionId = await openReplacement(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('https://chatgpt.com/');
-      return { submissionTargetUrl: 'https://chatgpt.com/', recoveredFromStaleBinding: true, browserSessionId: replacementSessionId };
-    }
-  }
-}
-
-async function submitChatgptPrompt(
-  controllerHome: string,
-  workId: string,
-  browserSessionId: string,
-  prompt: string,
-  targetUrl: string,
-  timeoutMs?: number,
-): Promise<string> {
-  await controllerBrowserAction(controllerHome, workId, 'fill', {
-    session_id: browserSessionId,
-    selector: CHATGPT_PROMPT_SELECTOR,
-    text: withForgePluginMention(prompt),
-    timeout_ms: timeoutMs ?? 60_000,
-    post_action_wait_ms: 100,
-  }, timeoutMs);
-  const sent = await controllerBrowserAction(controllerHome, workId, 'click', {
-    session_id: browserSessionId,
-    selector: CHATGPT_SEND_SELECTOR,
-    timeout_ms: timeoutMs ?? 60_000,
-    post_action_wait_ms: 1_000,
-  }, timeoutMs);
-  let observedUrl = resultUrl(sent) ?? targetUrl;
-  if (/\/c\/[^/?#]+/.test(observedUrl)) return observedUrl;
-  const deadline = Date.now() + Math.min(Math.max(timeoutMs ?? 8_000, 2_000), 8_000);
-  do {
-    const observed = await controllerBrowserAction(controllerHome, workId, 'query_all', {
-      session_id: browserSessionId,
-      selector: 'main',
-      limit: 1,
-      timeout_ms: Math.min(timeoutMs ?? 3_000, 3_000),
-    }, timeoutMs).catch(() => undefined);
-    observedUrl = observed ? resultUrl(observed) ?? observedUrl : observedUrl;
-    if (/\/c\/[^/?#]+/.test(observedUrl)) return observedUrl;
-    await new Promise((resolveWait) => setTimeout(resolveWait, 250));
-  } while (Date.now() < deadline);
-  throw new Error(`CHATGPT_AUTOMATION_SUBMISSION_NOT_CONFIRMED:${observedUrl}`);
-}
-
 export function withForgePluginMention(prompt: string): string {
   const value = prompt.trim();
   if (!value) throw new Error('CHATGPT_AUTOMATION_PROMPT_REQUIRED');
@@ -596,63 +246,75 @@ export function withForgePluginMention(prompt: string): string {
  * ChatGPT browser path without creating or requiring a WorkContract. The scope
  * id is only a stable browser correlation key (for example a Schedule id).
  */
-export async function runStandaloneChatgptPrompt(input: StandaloneChatgptPromptInput): Promise<WorkChatgptContinuationResult> {
+export async function runStandaloneChatgptPrompt(
+  input: StandaloneChatgptPromptInput,
+  dependencies: WorkChatgptContinuationDependencies = {},
+): Promise<WorkChatgptContinuationResult> {
   const model = normalizeModel(input.model);
   const reasoning = normalizeReasoning(input.reasoning);
   const tabPolicy = normalizeTabPolicy(input.tabPolicy);
-  const sessionId = resolveStandaloneChatgptBrowserSessionId(input);
   const browserScopeId = `standalone:${input.scopeId}`;
   const seedUrl = input.conversationUrl?.trim();
+  const { bridgeRuntime, host } = resolveChatgptProviderDeliveryHost(dependencies);
+  const sessionId = bridgeRuntime
+    ? stableChatgptWorkBridgeSessionId(input.repoId, browserScopeId)
+    : resolveStandaloneChatgptBrowserSessionId(input);
+  const targetUrl = seedUrl ?? 'https://chatgpt.com/';
 
   try {
-    await ensureControllerChatgptBrowser(input.controllerHome, browserScopeId);
-    const targetUrl = seedUrl ?? 'https://chatgpt.com/';
-    const navigation = await navigateWorkConversation(
-      input.controllerHome,
-      browserScopeId,
-      sessionId,
+    const delivery = await host.dispatch({
+      controllerHome: input.controllerHome,
+      repoId: input.repoId,
+      repoRoot: input.repoRoot ?? process.cwd(),
+      workId: browserScopeId,
+      prompt: input.prompt,
+      browserSessionId: sessionId,
       targetUrl,
-      input.timeoutMs,
-    );
-    const executionPreferenceVerified = await ensureChatgptExecutionPreference(
-      input.controllerHome,
-      browserScopeId,
-      navigation.browserSessionId,
       model,
       reasoning,
-      input.timeoutMs,
-    );
-    const observedUrl = await submitChatgptPrompt(
-      input.controllerHome,
-      browserScopeId,
-      navigation.browserSessionId,
-      input.prompt,
-      navigation.submissionTargetUrl,
-      input.timeoutMs,
-    );
-    const tabCleanup = await closeChatgptAutomationTabAfterDispatch(
-      input.controllerHome,
-      browserScopeId,
-      navigation.browserSessionId,
-      input.timeoutMs,
-    );
+      timeoutMs: input.timeoutMs,
+    });
+    if (delivery.status !== 'dispatch_confirmed') {
+      return {
+        status: 'failed',
+        provider: delivery.provider,
+        browserSessionId: delivery.browserSessionId,
+        conversationUrl: delivery.conversationUrl ?? seedUrl,
+        resumedFromBinding: false,
+        model,
+        reasoning,
+        tabPolicy,
+        executionPreferenceVerified: delivery.executionPreferenceVerified,
+        providerDeliveryStatus: delivery.status,
+        error: delivery.error ?? { code: `CHATGPT_PROVIDER_${delivery.status.toUpperCase()}`, message: delivery.status },
+      };
+    }
+    const tabCleanup = delivery.provider === 'controller-browser'
+      ? await closeChatgptAutomationTabAfterDispatch(
+          input.controllerHome,
+          browserScopeId,
+          delivery.browserSessionId,
+          input.timeoutMs,
+        )
+      : undefined;
     return {
       status: 'dispatched',
-      provider: 'controller-browser',
-      browserSessionId: navigation.browserSessionId,
-      conversationUrl: observedUrl,
+      provider: delivery.provider,
+      browserSessionId: delivery.browserSessionId,
+      conversationUrl: delivery.conversationUrl ?? targetUrl,
       resumedFromBinding: false,
       model,
       reasoning,
       tabPolicy,
-      executionPreferenceVerified,
-      tabCleanupStatus: tabCleanup.status,
-      ...(tabCleanup.error ? { tabCleanupError: tabCleanup.error } : {}),
+      executionPreferenceVerified: delivery.executionPreferenceVerified,
+      providerDeliveryStatus: delivery.status,
+      ...(tabCleanup ? { tabCleanupStatus: tabCleanup.status } : {}),
+      ...(tabCleanup?.error ? { tabCleanupError: tabCleanup.error } : {}),
     };
   } catch (error) {
     return {
       status: 'failed',
-      provider: 'controller-browser',
+      provider: bridgeRuntime ? 'chatgpt-bridge' : 'controller-browser',
       browserSessionId: sessionId,
       conversationUrl: seedUrl,
       resumedFromBinding: false,
@@ -661,7 +323,7 @@ export async function runStandaloneChatgptPrompt(input: StandaloneChatgptPromptI
       tabPolicy,
       executionPreferenceVerified: false,
       error: {
-        code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : 'CHATGPT_CONTROLLER_BROWSER_FAILED',
+        code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : bridgeRuntime ? 'CHATGPT_BRIDGE_DISPATCH_FAILED' : 'CHATGPT_CONTROLLER_BROWSER_FAILED',
         message: error instanceof Error ? error.message : String(error),
       },
     };
@@ -672,13 +334,54 @@ export async function runStandaloneChatgptPrompt(input: StandaloneChatgptPromptI
  * Dispatches a bounded resume prompt to one controller-owned ChatGPT Web tab.
  * Chat history is transport context only. Forge Work/Plan/evidence remain authoritative.
  */
-export async function runWorkChatgptContinuation(input: WorkChatgptContinuationInput): Promise<WorkChatgptContinuationResult> {
+export async function runWorkChatgptContinuation(
+  input: WorkChatgptContinuationInput,
+  dependencies: WorkChatgptContinuationDependencies = {},
+): Promise<WorkChatgptContinuationResult> {
   const store = { controllerHome: input.controllerHome, repoId: input.repoId };
   const existing = getChatgptWorkConversationBinding(store, input.workId);
-  const seedUrl = input.conversationUrl?.trim() || existing?.conversationUrl;
+  const authorizationGrantRefs = new Set(
+    [...(existing?.authorizationGrantRefs ?? []), ...(input.authorizationGrantRefs ?? [])]
+      .map((ref) => ref.trim())
+      .filter(Boolean),
+  );
+  const transportConversation = input.transportConversation ?? 'bound';
+  const seedUrl = transportConversation === 'fresh' ? undefined : input.conversationUrl?.trim() || existing?.conversationUrl;
   const model = normalizeModel(input.model);
-  const reasoning = normalizeReasoning(input.reasoning);
-  const tabPolicy = normalizeTabPolicy(input.tabPolicy);
+  const reasoning = normalizeControllerReasoning(input.reasoning);
+  const tabPolicy = transportConversation === 'fresh' ? 'new' : normalizeTabPolicy(input.tabPolicy);
+  const { bridgeRuntime, host } = resolveChatgptProviderDeliveryHost(dependencies);
+  const authorityInputError = controllerRoundAuthorityInputError(input);
+  if (authorityInputError) {
+    const browserSessionId = bridgeRuntime
+      ? stableChatgptWorkBridgeSessionId(input.repoId, input.workId)
+      : resolveChatgptWorkBrowserSessionId({
+          repoId: input.repoId,
+          workId: input.workId,
+          tabPolicy,
+          explicitSessionId: input.browserSessionId,
+          boundSessionId: existing?.latestBrowserSessionId,
+        });
+    return {
+      status: 'failed',
+      provider: bridgeRuntime ? 'chatgpt-bridge' : 'controller-browser',
+      browserSessionId,
+      conversationUrl: seedUrl,
+      conversationId: existing?.conversationId,
+      localAlias: existing?.localAlias,
+      resumedFromBinding: Boolean(existing),
+      model,
+      reasoning,
+      tabPolicy,
+      executionPreferenceVerified: false,
+      authorizationGrantRefs: [...authorizationGrantRefs],
+      error: {
+        code: 'CHATGPT_CONTROLLER_ROUND_AUTHORITY_INCOMPLETE',
+        message: authorityInputError.message,
+      },
+    };
+  }
+
   const sessionId = resolveChatgptWorkBrowserSessionId({
     repoId: input.repoId,
     workId: input.workId,
@@ -687,63 +390,92 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
     boundSessionId: existing?.latestBrowserSessionId,
   });
   let binding: ChatgptWorkConversationBinding | undefined = existing;
+  const deliverySessionId = bridgeRuntime
+    ? stableChatgptWorkBridgeSessionId(input.repoId, input.workId)
+    : sessionId;
 
   try {
     const work = getWorkContract(store, input.workId);
     if (!work || work.repoId !== input.repoId) {
       throw new Error(`CHATGPT_WORK_CONTRACT_NOT_FOUND: ${input.repoId}:${input.workId}`);
     }
-    await ensureControllerChatgptBrowser(input.controllerHome, input.workId);
-    if (seedUrl && !binding && hasChatgptConversationIdentity(seedUrl)) {
+    const targetForgeInstanceId = work.executionPlacement?.forgeInstanceId?.trim();
+    if (targetForgeInstanceId) {
+      const currentForgeInstanceId = readForgeInstanceIdentity(input.controllerHome)?.instanceId?.trim();
+      if (currentForgeInstanceId !== targetForgeInstanceId) {
+        throw new ChatgptExecutionPlacementError(targetForgeInstanceId, currentForgeInstanceId);
+      }
+    }
+    if (!bridgeRuntime && seedUrl && !binding && hasChatgptConversationIdentity(seedUrl)) {
       binding = bindChatgptWorkConversation(store, {
         workId: input.workId,
         conversationUrl: seedUrl,
-        latestBrowserSessionId: sessionId,
+        latestBrowserSessionId: deliverySessionId,
+        authorizationGrantRefs: [...authorizationGrantRefs],
         localAlias: input.title,
       });
     }
-    const targetUrl = binding?.conversationUrl ?? seedUrl ?? 'https://chatgpt.com/';
-    const navigation = await navigateWorkConversation(
-      input.controllerHome,
-      input.workId,
-      sessionId,
-      targetUrl,
-      input.timeoutMs,
-    );
-    const executionPreferenceVerified = await ensureChatgptExecutionPreference(
-      input.controllerHome,
-      input.workId,
-      navigation.browserSessionId,
-      model,
-      reasoning,
-      input.timeoutMs,
+    const targetUrl = transportConversation === 'fresh' ? 'https://chatgpt.com/' : binding?.conversationUrl ?? seedUrl ?? 'https://chatgpt.com/';
+    const renderedPrompt = `${workflowToolAttributionInstruction(input)}\n\n${input.prompt}`;
+    const delivery = await withChatgptBrowserActionOrigin(
+      { surface: input.originSurface ?? 'chatgpt-action', actor: 'chatgpt-work-continuation' },
+      () => host.dispatch({
+        controllerHome: input.controllerHome,
+        repoId: input.repoId,
+        repoRoot: input.repoRoot,
+        workId: input.workId,
+        prompt: renderedPrompt,
+        browserSessionId: deliverySessionId,
+        targetUrl,
+        model,
+        reasoning,
+        timeoutMs: input.timeoutMs,
+      }),
+      authorizationGrantRefs,
     );
-    const observedUrl = await submitChatgptPrompt(input.controllerHome, input.workId, navigation.browserSessionId, `${workflowToolAttributionInstruction(input.workId)}\n\n${input.prompt}`, navigation.submissionTargetUrl, input.timeoutMs);
-    if (/\/c\/[^/?#]+/.test(observedUrl)) {
+    const observedUrl = delivery.conversationUrl ?? targetUrl;
+    const mayPersistObservedConversation = delivery.status === 'dispatch_confirmed' || delivery.status === 'outcome_unknown';
+    if (mayPersistObservedConversation && /\/c\/[^/?#]+/.test(observedUrl)) {
       const observedIdentity = parseChatgptConversationIdentity(observedUrl);
       binding = binding && binding.conversationId !== observedIdentity.conversationId
         ? rebindChatgptWorkConversation(store, {
-          workId: input.workId,
-          previousConversationId: binding.conversationId,
-          conversationUrl: observedUrl,
-          latestBrowserSessionId: navigation.browserSessionId,
-          localAlias: binding.localAlias ?? input.title,
-        })
+            workId: input.workId,
+            previousConversationId: binding.conversationId,
+            conversationUrl: observedUrl,
+            latestBrowserSessionId: delivery.browserSessionId,
+            authorizationGrantRefs: [...authorizationGrantRefs],
+            localAlias: binding.localAlias ?? input.title,
+          })
         : bindChatgptWorkConversation(store, {
-          workId: input.workId,
-          conversationUrl: observedUrl,
-          latestBrowserSessionId: navigation.browserSessionId,
-          localAlias: binding?.localAlias ?? input.title,
-        });
+            workId: input.workId,
+            conversationUrl: observedUrl,
+            latestBrowserSessionId: delivery.browserSessionId,
+            authorizationGrantRefs: [...authorizationGrantRefs],
+            localAlias: binding?.localAlias ?? input.title,
+          });
+    }
+    if (delivery.status !== 'dispatch_confirmed') {
+      return {
+        status: 'failed',
+        provider: delivery.provider,
+        browserSessionId: delivery.browserSessionId,
+        conversationUrl: binding?.conversationUrl ?? delivery.conversationUrl ?? seedUrl,
+        conversationId: binding?.conversationId,
+        localAlias: binding?.localAlias,
+        resumedFromBinding: Boolean(existing),
+        model,
+        reasoning,
+        tabPolicy,
+        executionPreferenceVerified: delivery.executionPreferenceVerified,
+        authorizationGrantRefs: [...authorizationGrantRefs],
+        providerDeliveryStatus: delivery.status,
+        error: delivery.error ?? { code: `CHATGPT_PROVIDER_${delivery.status.toUpperCase()}`, message: delivery.status },
+      };
     }
-    // Work-bound dispatch keeps the Forge-owned automation tab/session alive for
-    // the launched semantic Controller round. The exact Controller release path
-    // settles it after an explicit disposition. Closing here would race the new
-    // ChatGPT round and make dispatch success look like round completion.
     return {
       status: 'dispatched',
-      provider: 'controller-browser',
-      browserSessionId: navigation.browserSessionId,
+      provider: delivery.provider,
+      browserSessionId: delivery.browserSessionId,
       conversationUrl: binding?.conversationUrl ?? observedUrl,
       conversationId: binding?.conversationId,
       localAlias: binding?.localAlias,
@@ -751,13 +483,17 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
       model,
       reasoning,
       tabPolicy,
-      executionPreferenceVerified,
+      executionPreferenceVerified: delivery.executionPreferenceVerified,
+      authorizationGrantRefs: [...authorizationGrantRefs],
+      providerDeliveryStatus: delivery.status,
     };
   } catch (error) {
+    const provider = bridgeRuntime ? 'chatgpt-bridge' : 'controller-browser';
+    const fallbackSessionId = bridgeRuntime ? deliverySessionId : sessionId;
     return {
       status: 'failed',
-      provider: 'controller-browser',
-      browserSessionId: sessionId,
+      provider,
+      browserSessionId: fallbackSessionId,
       conversationUrl: binding?.conversationUrl ?? seedUrl,
       conversationId: binding?.conversationId,
       localAlias: binding?.localAlias,
@@ -766,8 +502,13 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
       reasoning,
       tabPolicy,
       executionPreferenceVerified: false,
+      authorizationGrantRefs: [...authorizationGrantRefs],
       error: {
-        code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : 'CHATGPT_CONTROLLER_BROWSER_FAILED',
+        code: error instanceof ChatgptExecutionPlacementError
+          ? error.code
+          : error instanceof Error && error.message.includes(':')
+            ? error.message.split(':', 1)[0]
+            : bridgeRuntime ? 'CHATGPT_BRIDGE_DISPATCH_FAILED' : 'CHATGPT_CONTROLLER_BROWSER_FAILED',
         message: error instanceof Error ? error.message : String(error),
       },
     };