@moretea-labs/forge 1.8.0 → 1.8.1

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

@@ -7,6 +7,7 @@ import {
   DEFAULT_CHATGPT_AUTOMATION_MODEL,
   DEFAULT_CHATGPT_AUTOMATION_REASONING,
   DEFAULT_CHATGPT_AUTOMATION_TAB_POLICY,
+  dispatchWithChatgptProviderBackpressure,
   type ChatgptAutomationReasoning,
   type ChatgptAutomationTabCleanupStatus,
   type ChatgptAutomationTabPolicy,
@@ -21,16 +22,6 @@ import {
   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,
-  hasChatgptConversationIdentity,
-  parseChatgptConversationIdentity,
-  rebindChatgptWorkConversation,
-  type ChatgptWorkConversationBinding,
-} from '../../../../adapters/chatgpt/work-conversation-binding-store';
 
 export {
   CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN,
@@ -56,48 +47,8 @@ export {
   settleWorkChatgptAutomationTab,
 } from '../../../../adapters/chatgpt/browser-delivery-runtime';
 
-const LEGACY_CONTROLLER_CHATGPT_SESSION_ID = 'forge-chatgpt-supercontroller';
 export const DEFAULT_CHATGPT_AUTOMATION_PLUGIN_MENTION = '@forge';
 
-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;
-  repoId: string;
-  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;
@@ -137,27 +88,8 @@ export interface StandaloneChatgptPromptInput {
   reasoning?: ChatgptAutomationReasoning;
   tabPolicy?: ChatgptAutomationTabPolicy;
   timeoutMs?: number;
-}
-
-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 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');
+  /** Explicit Browser grant refs already authorized by the owning durable workflow/controller binding. */
+  authorizationGrantRefs?: readonly string[];
 }
 
 function normalizeModel(value?: string): string {
@@ -170,12 +102,6 @@ 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;
 }
@@ -195,18 +121,13 @@ function resolveChatgptProviderDeliveryHost(
   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);
+export function stableChatgptWorkBridgeSessionId(_repoId: string, workId: string): string {
+  const digest = createHash('sha256').update(`bridge\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);
+export function stableStandaloneChatgptBrowserSessionId(_repoId: string, scopeId: string): string {
+  const digest = createHash('sha256').update(`standalone\n${scopeId}`).digest('hex').slice(0, 20);
   return `forge-chatgpt-standalone-${digest}`;
 }
 
@@ -217,23 +138,6 @@ function resolveStandaloneChatgptBrowserSessionId(input: StandaloneChatgptPrompt
   return input.browserSessionId?.trim() || stable;
 }
 
-export function resolveChatgptWorkBrowserSessionId(input: {
-  repoId: string;
-  workId: string;
-  tabPolicy?: ChatgptAutomationTabPolicy;
-  explicitSessionId?: string;
-  boundSessionId?: string;
-}): string {
-  const policy = normalizeTabPolicy(input.tabPolicy);
-  const stable = stableChatgptWorkBrowserSessionId(input.repoId, input.workId);
-  if (policy === 'new') return `${stable}-${randomUUID().slice(0, 8)}`;
-  const explicit = input.explicitSessionId?.trim();
-  if (explicit && explicit !== LEGACY_CONTROLLER_CHATGPT_SESSION_ID) return explicit;
-  const bound = input.boundSessionId?.trim();
-  if (bound && bound !== LEGACY_CONTROLLER_CHATGPT_SESSION_ID) return bound;
-  return stable;
-}
-
 export function withForgePluginMention(prompt: string): string {
   const value = prompt.trim();
   if (!value) throw new Error('CHATGPT_AUTOMATION_PROMPT_REQUIRED');
@@ -260,20 +164,27 @@ export async function runStandaloneChatgptPrompt(
     ? stableChatgptWorkBridgeSessionId(input.repoId, browserScopeId)
     : resolveStandaloneChatgptBrowserSessionId(input);
   const targetUrl = seedUrl ?? 'https://chatgpt.com/';
+  const authorizationGrantRefs = new Set(
+    (input.authorizationGrantRefs ?? []).map((ref) => ref.trim()).filter(Boolean),
+  );
 
   try {
-    const delivery = await host.dispatch({
-      controllerHome: input.controllerHome,
-      repoId: input.repoId,
-      repoRoot: input.repoRoot ?? process.cwd(),
-      workId: browserScopeId,
-      prompt: input.prompt,
-      browserSessionId: sessionId,
-      targetUrl,
-      model,
-      reasoning,
-      timeoutMs: input.timeoutMs,
-    });
+    const delivery = await withChatgptBrowserActionOrigin(
+      { surface: 'chatgpt-action', actor: 'chatgpt-standalone-prompt' },
+      () => dispatchWithChatgptProviderBackpressure(input.controllerHome, () => host.dispatch({
+        controllerHome: input.controllerHome,
+        repoId: input.repoId,
+        repoRoot: input.repoRoot ?? process.cwd(),
+        workId: browserScopeId,
+        prompt: input.prompt,
+        browserSessionId: sessionId,
+        targetUrl,
+        model,
+        reasoning,
+        timeoutMs: input.timeoutMs,
+      })),
+      authorizationGrantRefs,
+    );
     if (delivery.status !== 'dispatch_confirmed') {
       return {
         status: 'failed',
@@ -285,6 +196,7 @@ export async function runStandaloneChatgptPrompt(
         reasoning,
         tabPolicy,
         executionPreferenceVerified: delivery.executionPreferenceVerified,
+        authorizationGrantRefs: [...authorizationGrantRefs],
         providerDeliveryStatus: delivery.status,
         error: delivery.error ?? { code: `CHATGPT_PROVIDER_${delivery.status.toUpperCase()}`, message: delivery.status },
       };
@@ -322,193 +234,9 @@ export async function runStandaloneChatgptPrompt(
       reasoning,
       tabPolicy,
       executionPreferenceVerified: false,
-      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),
-      },
-    };
-  }
-}
-
-/**
- * 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,
-  dependencies: WorkChatgptContinuationDependencies = {},
-): Promise<WorkChatgptContinuationResult> {
-  const store = { controllerHome: input.controllerHome, repoId: input.repoId };
-  const existing = getChatgptWorkConversationBinding(store, input.workId);
-  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 = 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,
-    tabPolicy,
-    explicitSessionId: input.browserSessionId,
-    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}`);
-    }
-    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: deliverySessionId,
-        authorizationGrantRefs: [...authorizationGrantRefs],
-        localAlias: input.title,
-      });
-    }
-    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 = 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: delivery.browserSessionId,
-            authorizationGrantRefs: [...authorizationGrantRefs],
-            localAlias: binding.localAlias ?? input.title,
-          })
-        : bindChatgptWorkConversation(store, {
-            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 },
-      };
-    }
-    return {
-      status: 'dispatched',
-      provider: delivery.provider,
-      browserSessionId: delivery.browserSessionId,
-      conversationUrl: binding?.conversationUrl ?? observedUrl,
-      conversationId: binding?.conversationId,
-      localAlias: binding?.localAlias,
-      resumedFromBinding: Boolean(existing),
-      model,
-      reasoning,
-      tabPolicy,
-      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,
-      browserSessionId: fallbackSessionId,
-      conversationUrl: binding?.conversationUrl ?? seedUrl,
-      conversationId: binding?.conversationId,
-      localAlias: binding?.localAlias,
-      resumedFromBinding: Boolean(existing),
-      model,
-      reasoning,
-      tabPolicy,
-      executionPreferenceVerified: false,
-      authorizationGrantRefs: [...authorizationGrantRefs],
-      error: {
-        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',
+        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),
       },
     };

package/src/runtime/control-plane/launcher/local-conversation-controller.ts

@@ -0,0 +1,238 @@
+import { spawn } from 'child_process';
+import { mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { redactProcessOutput } from '../../../effects/process-runner';
+import { resolveProviderMcpBootstrap } from './provider-mcp-bootstrap';
+import {
+  buildCodexControllerInvocation,
+  launcherProcessEnvironment,
+  resolveLauncherExecutable,
+} from './thin-launcher';
+
+const LOCAL_CONVERSATION_TIMEOUT_MS = 5 * 60_000;
+const LOCAL_CONVERSATION_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+const LOCAL_CONVERSATION_MAX_PROMPT_CHARS = 20_000;
+const LOCAL_CONVERSATION_ID = /^[A-Za-z0-9._:-]{1,160}$/;
+
+export interface LocalConversationProviderStatus {
+  provider: 'codex';
+  status: 'ready' | 'not_configured' | 'unavailable';
+  label: string;
+  detail: string;
+  streaming: boolean;
+  tools: boolean;
+}
+
+export interface LocalConversationSendInput {
+  controllerHome: string;
+  conversationId: string;
+  providerSessionId?: string;
+  prompt: string;
+  repoId?: string;
+  timeoutMs?: number;
+}
+
+export interface LocalConversationSendResult {
+  provider: 'codex';
+  status: 'completed';
+  conversationId: string;
+  providerSessionId: string;
+  output: string;
+  toolActivityCount: number;
+}
+
+export interface ParsedCodexConversationEvents {
+  providerSessionId?: string;
+  output?: string;
+  toolActivityCount: number;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function boundedTimeout(value: number | undefined): number {
+  if (!Number.isFinite(value)) return LOCAL_CONVERSATION_TIMEOUT_MS;
+  return Math.max(5_000, Math.min(10 * 60_000, Math.trunc(value!)));
+}
+
+function agentMessageText(item: Record<string, unknown>): string | undefined {
+  if (typeof item.text === 'string' && item.text.trim()) return item.text.trim();
+  if (typeof item.output_text === 'string' && item.output_text.trim()) return item.output_text.trim();
+  if (!Array.isArray(item.content)) return undefined;
+  const text = item.content.map((entry) => {
+    const content = record(entry);
+    if (!content) return '';
+    if (typeof content.text === 'string') return content.text;
+    if (typeof content.output_text === 'string') return content.output_text;
+    return '';
+  }).filter(Boolean).join('\n').trim();
+  return text || undefined;
+}
+
+export function parseCodexConversationJsonl(stdout: string): ParsedCodexConversationEvents {
+  let providerSessionId: string | undefined;
+  let output: string | undefined;
+  let toolActivityCount = 0;
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{')) continue;
+    let event: Record<string, unknown> | undefined;
+    try { event = record(JSON.parse(trimmed)); } catch { continue; }
+    if (!event) continue;
+    const type = typeof event.type === 'string' ? event.type : '';
+    if (type === 'thread.started' && typeof event.thread_id === 'string' && event.thread_id.trim()) {
+      providerSessionId = event.thread_id.trim();
+    }
+    if (type !== 'item.completed') continue;
+    const item = record(event.item);
+    if (!item) continue;
+    const itemType = typeof item.type === 'string' ? item.type : '';
+    if (itemType === 'agent_message') {
+      output = agentMessageText(item) ?? output;
+      continue;
+    }
+    if (['mcp_tool_call', 'command_execution', 'file_change', 'web_search'].includes(itemType)) {
+      toolActivityCount += 1;
+    }
+  }
+  return { providerSessionId, output, toolActivityCount };
+}
+
+function localConversationCwd(): string {
+  const root = join(tmpdir(), 'forge-local-controller');
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  return root;
+}
+
+function conversationPrompt(prompt: string, repoId?: string): string {
+  return [
+    'You are the Forge Desktop local controller.',
+    'Use the injected Forge MCP capabilities for repository, Runtime, and other Forge operations. Do not create Requirement, Plan, Work, ControllerRound, or a scheduled continuation unless the user explicitly requests that durable lifecycle.',
+    repoId
+      ? `Attached repository: ${repoId}. Pass repo_id=${repoId} to Forge capabilities that require repository scope.`
+      : 'No repository is attached. Do not guess a repository identity.',
+    '',
+    prompt,
+  ].join('\n');
+}
+
+export function readLocalConversationProviderStatus(cwd: string = process.cwd()): LocalConversationProviderStatus {
+  try {
+    resolveLauncherExecutable({ controllerType: 'codex', cwd });
+    return {
+      provider: 'codex',
+      status: 'ready',
+      label: 'Codex 已连接',
+      detail: '使用 Codex CLI 的现有登录；Forge 操作通过当前 Runtime MCP capability 执行。',
+      streaming: false,
+      tools: true,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const missing = message.startsWith('LAUNCHER_EXECUTABLE_UNAVAILABLE');
+    return {
+      provider: 'codex',
+      status: missing ? 'not_configured' : 'unavailable',
+      label: missing ? 'Codex CLI 未安装' : 'Codex 暂不可用',
+      detail: missing ? '安装并登录 Codex CLI 后即可使用本地会话。' : message,
+      streaming: false,
+      tools: false,
+    };
+  }
+}
+
+function runCodexConversation(
+  executable: string,
+  args: string[],
+  env: NodeJS.ProcessEnv,
+  cwd: string,
+  timeoutMs: number,
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, args, {
+      cwd,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const fail = (error: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    };
+    const append = (current: string, chunk: unknown, stream: 'stdout' | 'stderr'): string => {
+      const next = `${current}${Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk ?? '')}`;
+      if (Buffer.byteLength(next, 'utf8') > LOCAL_CONVERSATION_MAX_OUTPUT_BYTES) {
+        child.kill('SIGTERM');
+        fail(new Error(`LOCAL_CONVERSATION_${stream.toUpperCase()}_TOO_LARGE`));
+        return current;
+      }
+      return next;
+    };
+    child.stdout?.on('data', (chunk) => { stdout = append(stdout, chunk, 'stdout'); });
+    child.stderr?.on('data', (chunk) => { stderr = append(stderr, chunk, 'stderr'); });
+    child.once('error', (error) => fail(new Error(`LOCAL_CONVERSATION_PROVIDER_START_FAILED: ${error.message}`)));
+    child.once('close', (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code !== 0) {
+        const detail = redactProcessOutput(stderr.trim() || stdout.trim()).replace(/\s+/g, ' ').slice(0, 1200);
+        reject(new Error(`LOCAL_CONVERSATION_PROVIDER_FAILED: code=${String(code ?? 'null')} signal=${signal ?? 'none'}${detail ? `; ${detail}` : ''}`));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      fail(new Error('LOCAL_CONVERSATION_PROVIDER_TIMEOUT'));
+    }, timeoutMs);
+  });
+}
+
+export async function sendLocalConversation(input: LocalConversationSendInput): Promise<LocalConversationSendResult> {
+  const conversationId = input.conversationId.trim();
+  const prompt = input.prompt.trim();
+  const providerSessionId = input.providerSessionId?.trim();
+  const repoId = input.repoId?.trim();
+  if (!LOCAL_CONVERSATION_ID.test(conversationId)) throw new Error('LOCAL_CONVERSATION_ID_INVALID');
+  if (!prompt || prompt.length > LOCAL_CONVERSATION_MAX_PROMPT_CHARS) throw new Error('LOCAL_CONVERSATION_PROMPT_INVALID');
+  if (providerSessionId && !LOCAL_CONVERSATION_ID.test(providerSessionId)) throw new Error('LOCAL_CONVERSATION_PROVIDER_SESSION_INVALID');
+  if (repoId && repoId.length > 256) throw new Error('LOCAL_CONVERSATION_REPOSITORY_INVALID');
+
+  const cwd = localConversationCwd();
+  const executable = resolveLauncherExecutable({ controllerType: 'codex', cwd });
+  const bootstrap = resolveProviderMcpBootstrap(input.controllerHome, 'codex', `local-${conversationId}`);
+  const invocation = buildCodexControllerInvocation({
+    executable,
+    prompt: conversationPrompt(prompt, repoId),
+    mcpBootstrap: bootstrap,
+    sandbox: 'read-only',
+    resumeSessionId: providerSessionId,
+    json: true,
+  });
+  const completed = await runCodexConversation(
+    invocation.executable,
+    invocation.args,
+    launcherProcessEnvironment(bootstrap.env),
+    cwd,
+    boundedTimeout(input.timeoutMs),
+  );
+  const parsed = parseCodexConversationJsonl(completed.stdout);
+  const resolvedProviderSessionId = parsed.providerSessionId ?? providerSessionId;
+  if (!resolvedProviderSessionId) throw new Error('LOCAL_CONVERSATION_PROVIDER_SESSION_MISSING');
+  if (!parsed.output?.trim()) throw new Error('LOCAL_CONVERSATION_RESPONSE_MISSING');
+  return {
+    provider: 'codex',
+    status: 'completed',
+    conversationId,
+    providerSessionId: resolvedProviderSessionId,
+    output: parsed.output.trim(),
+    toolActivityCount: parsed.toolActivityCount,
+  };
+}

package/src/runtime/control-plane/launcher/provider-mcp-bootstrap.ts

@@ -73,8 +73,11 @@ export function codexMcpConfigArgs(bootstrap: ProviderMcpBootstrap): string[] {
     .map(([key, value]) => `${JSON.stringify(key)}=${JSON.stringify(value)}`)
     .join(',')}}`;
   return [
+    // Replace the entire table: Codex rejects a merged URL + persisted stdio
+    // transport even when command/args are overridden separately.
+    '-c', `mcp_servers.forge={url=${JSON.stringify(bootstrap.url)}, bearer_token_env_var=${JSON.stringify(bootstrap.bearerTokenEnvVar)}, http_headers=${headerTable}}`,
+    // Keep the explicit URL override visible for diagnostics; the complete
+    // table above has already removed the persisted stdio transport.
     '-c', `mcp_servers.forge.url=${JSON.stringify(bootstrap.url)}`,
-    '-c', `mcp_servers.forge.bearer_token_env_var=${JSON.stringify(bootstrap.bearerTokenEnvVar)}`,
-    '-c', `mcp_servers.forge.http_headers=${headerTable}`,
   ];
 }