@moretea-labs/forge 1.6.0 → 1.7.1

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

@@ -1,10 +1,13 @@
 import { createHash, randomUUID } from 'crypto';
-import { executeBrowserPluginAction, readBrowserPluginConfiguration } from '../../plugins/browser-adapter';
+import { buildBrowserPluginManifest, executeBrowserPluginAction } from '../../plugins/browser-adapter';
 import { controllerPluginRepository } from '../../plugins/store';
 import { getWorkContract } from '../facade/work-contract-store';
 import {
   bindChatgptWorkConversation,
   getChatgptWorkConversationBinding,
+  hasChatgptConversationIdentity,
+  parseChatgptConversationIdentity,
+  rebindChatgptWorkConversation,
   type ChatgptWorkConversationBinding,
 } from './chatgpt-work-binding-store';
 
@@ -14,13 +17,17 @@ 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"]';
-const CHATGPT_INTELLIGENCE_CONTROL_SELECTOR = 'main button';
+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 interface WorkChatgptContinuationInput {
   controllerHome: string;
@@ -37,33 +44,6 @@ export interface WorkChatgptContinuationInput {
   timeoutMs?: number;
 }
 
-export interface ScheduledChatgptPromptInput {
-  controllerHome: string;
-  repoId: string;
-  automationId: string;
-  prompt: string;
-  title?: string;
-  browserSessionId?: string;
-  conversationUrl?: string;
-  model?: string;
-  reasoning?: ChatgptAutomationReasoning;
-  tabPolicy?: ChatgptAutomationTabPolicy;
-  timeoutMs?: number;
-}
-
-export interface ScheduledChatgptPromptResult {
-  status: 'dispatched' | 'failed';
-  provider: 'controller-browser';
-  browserSessionId: string;
-  conversationUrl?: string;
-  model: string;
-  reasoning: ChatgptAutomationReasoning;
-  tabPolicy: ChatgptAutomationTabPolicy;
-  executionPreferenceVerified: boolean;
-  reusedSession: boolean;
-  error?: { code: string; message: string };
-}
-
 export interface WorkChatgptContinuationResult {
   status: 'dispatched' | 'failed';
   provider: 'controller-browser';
@@ -76,15 +56,42 @@ export interface WorkChatgptContinuationResult {
   reasoning: ChatgptAutomationReasoning;
   tabPolicy: ChatgptAutomationTabPolicy;
   executionPreferenceVerified: boolean;
+  tabCleanupStatus?: ChatgptAutomationTabCleanupStatus;
+  tabCleanupError?: { code: string; message: string };
   error?: { code: string; message: string };
 }
 
+export interface StandaloneChatgptPromptInput {
+  controllerHome: string;
+  repoId: string;
+  scopeId: string;
+  prompt: string;
+  browserSessionId?: string;
+  conversationUrl?: string;
+  model?: string;
+  reasoning?: ChatgptAutomationReasoning;
+  tabPolicy?: ChatgptAutomationTabPolicy;
+  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,
@@ -102,7 +109,7 @@ async function controllerBrowserAction(
     pluginId: 'browser',
     actionId,
     requestId: requestId(workId, actionId),
-    args,
+    args: chatgptBrowserActionArgs(actionId, args),
     timeoutMs,
     origin: { surface: 'schedule', actor: 'chatgpt-work-continuation' },
   });
@@ -112,18 +119,12 @@ async function ensureControllerChatgptBrowser(controllerHome: string, workId: st
   const repository = controllerPluginRepository(controllerHome);
   const repoRoot = repository.canonicalRoot ?? repository.localRoot;
   if (!repoRoot) throw new Error('CHATGPT_CONTROLLER_BROWSER_ROOT_UNAVAILABLE');
-  const existing = readBrowserPluginConfiguration(repoRoot);
-  await controllerBrowserAction(controllerHome, workId, 'configure', {
-    enabled: true,
-    ...(!existing.enabled ? {
-      browser_mode: 'attach_preferred',
-      profile_mode: 'repo_local',
-      browser_channel: 'chromium',
-      cdp_attach_fallback: 'fail_closed',
-      native_attach_mode: 'auto',
-      native_browser_candidates: ['chrome'],
-    } : {}),
-  });
+  // 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 stringField(value: unknown): string | undefined {
@@ -149,9 +150,16 @@ export function stableChatgptWorkBrowserSessionId(repoId: string, workId: string
   return `forge-chatgpt-work-${digest}`;
 }
 
-export function stableChatgptAutomationBrowserSessionId(repoId: string, automationId: string): string {
-  const digest = createHash('sha256').update(`${repoId}\nautomation\n${automationId}`).digest('hex').slice(0, 20);
-  return `forge-chatgpt-automation-${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}`;
+}
+
+function resolveStandaloneChatgptBrowserSessionId(input: StandaloneChatgptPromptInput): string {
+  const policy = normalizeTabPolicy(input.tabPolicy);
+  const stable = stableStandaloneChatgptBrowserSessionId(input.repoId, input.scopeId);
+  if (policy === 'new') return `${stable}-${randomUUID().slice(0, 8)}`;
+  return input.browserSessionId?.trim() || stable;
 }
 
 export function resolveChatgptWorkBrowserSessionId(input: {
@@ -189,10 +197,45 @@ 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 = label.toLowerCase().replace(/\s+/g, '');
-  return normalized.includes('5.6sol') || normalized.includes('gpt-5.6sol');
+  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 {
@@ -207,13 +250,38 @@ async function findChatgptIntelligenceControl(
   browserSessionId: string,
   timeoutMs?: number,
 ): Promise<BrowserQueryMatch | undefined> {
-  const result = await controllerBrowserAction(controllerHome, workId, 'query_all', {
-    session_id: browserSessionId,
-    selector: CHATGPT_INTELLIGENCE_CONTROL_SELECTOR,
-    limit: 50,
-    timeout_ms: timeoutMs ?? 60_000,
-  }, timeoutMs);
-  return queryMatches(result).find((match) => /(?:gpt-)?5\.6\s*sol/i.test(matchText(match)));
+  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(
@@ -222,10 +290,10 @@ async function waitForChatgptIntelligenceControl(
   browserSessionId: string,
   timeoutMs?: number,
 ): Promise<BrowserQueryMatch | undefined> {
-  const waitBudgetMs = Math.min(Math.max(timeoutMs ?? 12_000, 1_000), 12_000);
+  const { waitBudgetMs, probeTimeoutMs } = chatgptAutomationControlWaitBudgets(timeoutMs);
   const deadline = Date.now() + waitBudgetMs;
   do {
-    const control = await findChatgptIntelligenceControl(controllerHome, workId, browserSessionId, Math.min(waitBudgetMs, 5_000));
+    const control = await findChatgptIntelligenceControl(controllerHome, workId, browserSessionId, probeTimeoutMs);
     if (control) return control;
     if (Date.now() >= deadline) break;
     await new Promise((resolveWait) => setTimeout(resolveWait, 500));
@@ -233,6 +301,46 @@ async function waitForChatgptIntelligenceControl(
   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,
@@ -243,8 +351,15 @@ async function ensureChatgptExecutionPreference(
 ): 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) throw new Error('CHATGPT_AUTOMATION_INTELLIGENCE_CONTROL_UNAVAILABLE');
-  if (!modelLabelMatches(matchText(control), model)) throw new Error(`CHATGPT_AUTOMATION_MODEL_NOT_VERIFIED:${model}`);
+  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');
 
@@ -296,7 +411,9 @@ async function ensureChatgptExecutionPreference(
     throw new Error(`CHATGPT_AUTOMATION_REASONING_NOT_VERIFIED:${reasoning}`);
   }
   control = await findChatgptIntelligenceControl(controllerHome, workId, browserSessionId, timeoutMs) ?? control;
-  if (!modelLabelMatches(matchText(control), model)) throw new Error(`CHATGPT_AUTOMATION_MODEL_NOT_VERIFIED:${model}`);
+  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,
@@ -313,6 +430,122 @@ function resultUrl(result: Record<string, unknown>): string | undefined {
     ?? 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,
@@ -358,75 +591,77 @@ export function withForgePluginMention(prompt: string): string {
   return `${DEFAULT_CHATGPT_AUTOMATION_PLUGIN_MENTION} ${value}`;
 }
 
-export async function runScheduledChatgptPrompt(input: ScheduledChatgptPromptInput): Promise<ScheduledChatgptPromptResult> {
+/**
+ * Dispatches a bounded standalone prompt through the same controller-owned
+ * 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> {
   const model = normalizeModel(input.model);
   const reasoning = normalizeReasoning(input.reasoning);
   const tabPolicy = normalizeTabPolicy(input.tabPolicy);
-  const stableSessionId = stableChatgptAutomationBrowserSessionId(input.repoId, input.automationId);
-  const explicitSessionId = input.browserSessionId?.trim();
-  const sessionId = tabPolicy === 'new'
-    ? `${stableSessionId}-${randomUUID().slice(0, 8)}`
-    : explicitSessionId || stableSessionId;
-  const targetUrl = tabPolicy === 'new'
-    ? 'https://chatgpt.com/'
-    : input.conversationUrl?.trim() || 'https://chatgpt.com/';
-  let reusedSession = false;
+  const sessionId = resolveStandaloneChatgptBrowserSessionId(input);
+  const browserScopeId = `standalone:${input.scopeId}`;
+  const seedUrl = input.conversationUrl?.trim();
+
   try {
-    await ensureControllerChatgptBrowser(input.controllerHome, input.automationId);
-    if (tabPolicy !== 'new') {
-      try {
-        await controllerBrowserAction(input.controllerHome, input.automationId, 'get_text', {
-          session_id: sessionId,
-          selector: 'body',
-          max_chars: 1,
-          timeout_ms: Math.min(input.timeoutMs ?? 60_000, 3_000),
-        }, input.timeoutMs);
-        reusedSession = true;
-      } catch {
-        reusedSession = false;
-      }
-    }
-    if (!reusedSession) {
-      await controllerBrowserAction(input.controllerHome, input.automationId, 'open_page', {
-        session_id: sessionId,
-        url: targetUrl,
-        wait_until: 'domcontentloaded',
-        timeout_ms: input.timeoutMs ?? 60_000,
-        retries: 1,
-      }, input.timeoutMs);
-    }
-    const executionPreferenceVerified = await ensureChatgptExecutionPreference(
+    await ensureControllerChatgptBrowser(input.controllerHome, browserScopeId);
+    const targetUrl = seedUrl ?? 'https://chatgpt.com/';
+    const navigation = await navigateWorkConversation(
       input.controllerHome,
-      input.automationId,
+      browserScopeId,
       sessionId,
+      targetUrl,
+      input.timeoutMs,
+    );
+    const executionPreferenceVerified = await ensureChatgptExecutionPreference(
+      input.controllerHome,
+      browserScopeId,
+      navigation.browserSessionId,
       model,
       reasoning,
       input.timeoutMs,
     );
-    const observedUrl = await submitChatgptPrompt(input.controllerHome, input.automationId, sessionId, input.prompt, targetUrl, 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,
+    );
     return {
       status: 'dispatched',
       provider: 'controller-browser',
-      browserSessionId: sessionId,
+      browserSessionId: navigation.browserSessionId,
       conversationUrl: observedUrl,
+      resumedFromBinding: false,
       model,
       reasoning,
       tabPolicy,
       executionPreferenceVerified,
-      reusedSession,
+      tabCleanupStatus: tabCleanup.status,
+      ...(tabCleanup.error ? { tabCleanupError: tabCleanup.error } : {}),
     };
   } catch (error) {
     return {
       status: 'failed',
       provider: 'controller-browser',
       browserSessionId: sessionId,
+      conversationUrl: seedUrl,
+      resumedFromBinding: false,
       model,
       reasoning,
       tabPolicy,
       executionPreferenceVerified: false,
-      reusedSession,
       error: {
-        code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : 'CHATGPT_SCHEDULED_PROMPT_FAILED',
+        code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : 'CHATGPT_CONTROLLER_BROWSER_FAILED',
         message: error instanceof Error ? error.message : String(error),
       },
     };
@@ -459,7 +694,7 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
       throw new Error(`CHATGPT_WORK_CONTRACT_NOT_FOUND: ${input.repoId}:${input.workId}`);
     }
     await ensureControllerChatgptBrowser(input.controllerHome, input.workId);
-    if (seedUrl && !binding) {
+    if (seedUrl && !binding && hasChatgptConversationIdentity(seedUrl)) {
       binding = bindChatgptWorkConversation(store, {
         workId: input.workId,
         conversationUrl: seedUrl,
@@ -468,34 +703,47 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
       });
     }
     const targetUrl = binding?.conversationUrl ?? seedUrl ?? 'https://chatgpt.com/';
-    await controllerBrowserAction(input.controllerHome, input.workId, 'navigate', {
-      session_id: sessionId,
-      url: targetUrl,
-      wait_until: 'domcontentloaded',
-      timeout_ms: input.timeoutMs ?? 60_000,
-      retries: 1,
-    }, input.timeoutMs);
-    const executionPreferenceVerified = await ensureChatgptExecutionPreference(
+    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 observedUrl = await submitChatgptPrompt(input.controllerHome, input.workId, sessionId, `${workflowToolAttributionInstruction(input.workId)}\n\n${input.prompt}`, targetUrl, input.timeoutMs);
+    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)) {
-      binding = bindChatgptWorkConversation(store, {
-        workId: input.workId,
-        conversationUrl: observedUrl,
-        latestBrowserSessionId: sessionId,
-        localAlias: binding?.localAlias ?? input.title,
-      });
+      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,
+        })
+        : bindChatgptWorkConversation(store, {
+          workId: input.workId,
+          conversationUrl: observedUrl,
+          latestBrowserSessionId: navigation.browserSessionId,
+          localAlias: binding?.localAlias ?? input.title,
+        });
     }
+    // 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: sessionId,
+      browserSessionId: navigation.browserSessionId,
       conversationUrl: binding?.conversationUrl ?? observedUrl,
       conversationId: binding?.conversationId,
       localAlias: binding?.localAlias,