@moretea-labs/forge 1.7.1 → 1.8.0

package/adapters/chatgpt/controller-binding-store.ts

@@ -0,0 +1,55 @@
+import { withControllerLock } from '../../src/cli/repositories/locks';
+import { readControlPlaneRecord, writeControlPlaneRecord } from '../../src/runtime/control-plane/persistence/sqlite-store';
+import type { ControllerBinding } from '../../packages/kernel/controller/api/index';
+
+const NAMESPACE = 'chatgpt_controller_binding';
+
+export interface ChatgptControllerBindingPayload {
+  schemaVersion: 1;
+  bindingId: string;
+  repoId: string;
+  workId: string;
+  sessionId: string;
+  browserSessionId?: string;
+  conversationUrl?: string;
+  title?: string;
+  model?: string;
+  reasoning?: 'medium' | 'high' | 'xhigh';
+  tabPolicy?: 'auto' | 'reuse' | 'new';
+  timeoutMs?: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+function bindingId(repoId: string, workId: string): string {
+  return `chatgpt-controller:${repoId}:${workId}`;
+}
+
+export function upsertChatgptControllerBinding(
+  options: { controllerHome: string; repoId: string; now?: () => string },
+  input: Omit<ChatgptControllerBindingPayload, 'schemaVersion' | 'bindingId' | 'repoId' | 'createdAt' | 'updatedAt'>,
+): { binding: ControllerBinding; payload: ChatgptControllerBindingPayload } {
+  const id = bindingId(options.repoId, input.workId);
+  return withControllerLock(options.controllerHome, { scope: 'task', repoId: options.repoId, taskId: `chatgpt-controller-binding-${input.workId}` }, `chatgpt-controller-binding:${id}`, () => {
+    const current = readControlPlaneRecord<ChatgptControllerBindingPayload>(options.controllerHome, NAMESPACE, options.repoId, id);
+    const at = options.now?.() ?? new Date().toISOString();
+    const payload: ChatgptControllerBindingPayload = {
+      ...(current?.value ?? {} as ChatgptControllerBindingPayload),
+      ...input,
+      schemaVersion: 1, bindingId: id, repoId: options.repoId,
+      createdAt: current?.value.createdAt ?? at, updatedAt: at,
+    };
+    writeControlPlaneRecord(options.controllerHome, {
+      namespace: NAMESPACE, scope: options.repoId, key: id, schemaVersion: 1, value: payload,
+      action: current ? 'chatgpt_controller_binding_update' : 'chatgpt_controller_binding_create',
+      expectedRevision: current?.revision ?? null,
+    });
+    return { binding: { bindingId: id, hostKind: 'chatgpt', adapterRef: id }, payload };
+  });
+}
+
+export function getChatgptControllerBindingPayload(
+  options: { controllerHome: string; repoId: string }, adapterRef: string,
+): ChatgptControllerBindingPayload | undefined {
+  return readControlPlaneRecord<ChatgptControllerBindingPayload>(options.controllerHome, NAMESPACE, options.repoId, adapterRef)?.value;
+}

package/adapters/chatgpt/controller-host.ts

@@ -0,0 +1,119 @@
+import { createHash } from 'crypto';
+import {
+  getControllerRoundRelay,
+  type ControllerBinding,
+  type ControllerHost,
+  type ControllerRoundContext,
+} from '../../packages/kernel/controller/api/index';
+import { runWorkChatgptContinuation } from '../../src/runtime/control-plane/launcher/chatgpt-work-continuation';
+import { renderChatgptControllerRoundPrompt } from '../../src/runtime/root/controller-round-composition';
+import { getChatgptControllerBindingPayload } from './controller-binding-store';
+import { getChatgptWorkConversationBinding } from './work-conversation-binding-store';
+import { chatgptProviderDispatchReceiptId, classifyChatgptProviderFailure } from './provider-delivery';
+import { createHandoffItem, getHandoffItem } from '../../src/runtime/control-plane/facade/handoff-inbox-store';
+
+
+function providerUserActionHandoffId(repoId: string, workId: string, relayScopeId: string, authorityId: string): string {
+  const digest = createHash('sha256').update(`${repoId}\n${workId}\n${relayScopeId}\n${authorityId}`).digest('hex').slice(0, 20);
+  return `hnd-chatgpt-provider-auth-${digest}`;
+}
+
+function ensureChatgptProviderUserActionHandoff(
+  options: { controllerHome: string; repoId: string },
+  roundContext: ControllerRoundContext,
+  code: string,
+  message: string,
+): string {
+  const id = providerUserActionHandoffId(options.repoId, roundContext.workId, roundContext.relayScopeId, roundContext.authorityId);
+  const existing = getHandoffItem(options, id);
+  if (existing && existing.status === 'pending') return existing.id;
+  if (existing) return existing.id;
+  return createHandoffItem(options, {
+    id,
+    repoId: options.repoId,
+    workId: roundContext.workId,
+    title: 'ChatGPT provider authorization required',
+    severity: 'needs_review',
+    reason: message,
+    creationReason: 'missing_authorization',
+    summary: `Provider delivery is blocked until the user completes ChatGPT authentication or permission: ${code}`,
+    currentState: {
+      repoId: options.repoId,
+      workId: roundContext.workId,
+      statusSummary: 'ControllerRound is waiting for an explicit provider authentication/permission action.',
+      blockedBy: [code],
+      nextSafeAction: 'Complete the provider login/permission action, then resolve this Handoff to trigger a fresh continuation occurrence.',
+    },
+    evidenceRefs: [],
+    blockingDecision: 'Complete the required ChatGPT login or permission action.',
+    recommendedDecision: 'Complete provider authentication/permission and resume the same durable Work.',
+    recommendedPrompt: `Resume exact Work ${roundContext.workId} after provider authentication is complete.`,
+    suggestedNextActions: [],
+  }).id;
+}
+
+export function createChatgptControllerHost(options: {
+  controllerHome: string;
+  repoId: string;
+  repoRoot: string;
+}): ControllerHost {
+  return {
+    async resume(binding: ControllerBinding, roundContext: ControllerRoundContext) {
+      if (binding.hostKind !== 'chatgpt') return { accepted: false, reason: `CONTROLLER_HOST_KIND_MISMATCH:${binding.hostKind}` };
+      const payload = getChatgptControllerBindingPayload(options, binding.adapterRef);
+      if (!payload || payload.bindingId !== binding.bindingId || payload.workId !== roundContext.workId) {
+        return { accepted: false, reason: `CHATGPT_CONTROLLER_BINDING_NOT_FOUND:${binding.bindingId}` };
+      }
+      const relayStore = { controllerHome: options.controllerHome, repoId: options.repoId };
+      const relay = getControllerRoundRelay(relayStore, roundContext.workId);
+      if (!relay || relay.relayScopeId !== roundContext.relayScopeId || relay.authorityId !== roundContext.authorityId) {
+        return { accepted: false, reason: `CONTROLLER_ROUND_CONTEXT_STALE:${roundContext.workId}` };
+      }
+      const durableConversation = getChatgptWorkConversationBinding(relayStore, roundContext.workId);
+      const prompt = [
+        renderChatgptControllerRoundPrompt(relayStore, relay, { exactOriginWork: roundContext.exactOriginWork === true }),
+        roundContext.continuationHint?.trim() ? `Continuation hint: ${roundContext.continuationHint.trim()}` : '',
+      ].filter(Boolean).join('\n\n');
+      const result = await runWorkChatgptContinuation({
+        controllerHome: options.controllerHome,
+        repoId: options.repoId,
+        repoRoot: options.repoRoot,
+        workId: roundContext.workId,
+        prompt,
+        controllerAuthorityId: roundContext.authorityId,
+        relayScopeId: roundContext.relayScopeId,
+        title: payload.title,
+        browserSessionId: durableConversation?.latestBrowserSessionId ?? payload.browserSessionId,
+        conversationUrl: durableConversation?.conversationUrl ?? payload.conversationUrl,
+        model: payload.model ?? 'gpt-5.6',
+        reasoning: payload.reasoning ?? 'high',
+        tabPolicy: payload.tabPolicy ?? 'auto',
+        timeoutMs: payload.timeoutMs,
+        originSurface: 'schedule',
+      });
+      if (result.status === 'failed') {
+        const code = result.error?.code ?? 'CHATGPT_WORK_CONTINUATION_FAILED';
+        const message = result.error?.message ?? code;
+        const disposition = classifyChatgptProviderFailure(code, message);
+        if (disposition === 'outcome_unknown') {
+          throw new Error(`CONTROLLER_HOST_PROVIDER_DISPATCH_OUTCOME_UNKNOWN:${code}:${message}`);
+        }
+        if (disposition === 'wait_for_user') {
+          const handoffId = ensureChatgptProviderUserActionHandoff(options, roundContext, code, message);
+          return { accepted: false, waitForUser: true, handoffId, reason: message };
+        }
+        return { accepted: false, reason: message };
+      }
+      return {
+        accepted: true,
+        dispatchId: chatgptProviderDispatchReceiptId({
+          repoId: options.repoId,
+          workId: roundContext.workId,
+          relayScopeId: roundContext.relayScopeId,
+          controllerAuthorityId: roundContext.authorityId,
+          provider: result.provider,
+        }),
+      };
+    },
+  };
+}

package/adapters/chatgpt/controller-round-host.ts

@@ -0,0 +1,78 @@
+import {
+  readControllerRoundContextSnapshot,
+  type ControllerRoundRelayRecord,
+  type ControllerRoundRelayStoreOptions,
+} from '../../packages/kernel/controller/api/index';
+import { hasChatgptConversationIdentity, type ChatgptWorkConversationBinding } from './work-conversation-binding-store';
+
+/** ChatGPT-specific rendering of one provider-neutral Kernel ControllerRound. */
+export function buildChatgptControllerRoundPrompt(
+  options: ControllerRoundRelayStoreOptions,
+  record: ControllerRoundRelayRecord,
+  promptOptions: { exactOriginWork?: boolean } = {},
+): string {
+  const snapshot = readControllerRoundContextSnapshot(options, record);
+  const requirementLine = snapshot.requirement
+    ? `Requirement ${snapshot.requirement.requirementId}：state=${snapshot.requirement.state}；outcome=${snapshot.requirement.outcomeStatement}`
+    : `当前未绑定 durable Requirement；语义 relay scope 为 ${snapshot.relayScopeId}。`;
+  const workLines = snapshot.works.length > 0
+    ? snapshot.works.map((work) => {
+      const summary = `- ${work.workId}：status=${work.status}；phase=${work.phase}；updated=${work.updatedAt}；objective=${work.objective}`;
+      if (work.workId !== snapshot.originWorkId || work.acceptanceCriteria.length === 0) return summary;
+      return [
+        summary,
+        '  origin Work acceptanceCriteria（durable semantic contract）：',
+        ...work.acceptanceCriteria.map((criterion, index) => `  ${index + 1}. ${criterion}`),
+      ].join('\n');
+    }).join('\n')
+    : '- 未找到关联 Work 快照';
+  const originWork = snapshot.works.find((work) => work.workId === snapshot.originWorkId);
+  const terminalOriginGuidance = originWork?.status === 'completed'
+    ? `origin Work ${snapshot.originWorkId} 已 completed。禁止再次 controller_claim/reclaim 这个 terminal Work。若它是 validating 的 Plan predecessor：先用当前 round authority 做 plan_accept_step；再显式 start 唯一 successor（related_work_id=${snapshot.originWorkId}, work_relation=continue，并显式提供 work_kind/所需 engineering_preconditions 以及同一 controller_authority_id + relay_scope_id）；start 成功后 successor 只做 mechanical bind、不得抢占 ownership；随后显式提交 continue_immediately 得到 pending_release，最后 controller_release predecessor 触发新的 successor ControllerRound。`
+    : undefined;
+  const handoffLines = snapshot.handoffs.length > 0
+    ? snapshot.handoffs.map((handoff) => `- ${handoff.id}：status=${handoff.status}；work=${handoff.workId ?? 'repo'}；${handoff.title}；reason=${handoff.reason}`).join('\n')
+    : '- 当前没有 active linked Handoff';
+  return [
+    `继续 Forge Requirement/Goal relay ${snapshot.relayScopeId}，repo=${snapshot.repoId}。`,
+    '这是新的 ChatGPT controller round。第一步必须重新读取最新 Forge Requirement/Work/Handoff 状态；下面的快照只用于启动提示，不能代替 durable state。',
+    requirementLine,
+    `关联 Work 快照：\n${workLines}`,
+    'origin Work 的 objective 与 acceptanceCriteria 是本轮必须显式检查的 durable semantic contract；若最新事实满足其中更具体的终态义务，不得仅凭通用 disposition 指导改写成另一种终态。',
+    `Active Handoff 快照：\n${handoffLines}`,
+    ...(snapshot.assistantContext ? [snapshot.assistantContext] : []),
+    ...(snapshot.executionQualitySignals?.length ? [
+      `Execution quality evidence (advisory): ${JSON.stringify(snapshot.executionQualitySignals)}`,
+      'Review this evidence before repeating the same operation. Diagnose semantically; record whether an adjustment is justified. Do not infer a bug from edit counts, discard mandatory checks, widen authority or create another supervisor.',
+    ] : []),
+    promptOptions.exactOriginWork
+      ? `这是 Work-bound scheduled round。只允许 claim 并推进 origin Work ${snapshot.originWorkId}。不得选择、启动、delegate、resume sibling Work，不得新建 schedule，也不得扩大 scope。如果经过一次有界诊断或修复后仍无法安全推进，记录精确证据，提交 wait 或带 active Handoff 的 wait_for_user，释放 ownership，然后结束本轮。`
+      : `上一轮 relay 的 origin Work 是 ${snapshot.originWorkId}。不要假设下一步必须继续该 Work；必须依据最新 semantic state 选择、启动或 claim 正确的 Work。`,
+    ...(terminalOriginGuidance ? [terminalOriginGuidance] : []),
+    `机械 relay 预算：round=${snapshot.round.count}/${snapshot.round.maxRounds}；repeated_state=${snapshot.round.repeatedStateCount}/${snapshot.round.maxRepeatedState}；consecutive_failures=${snapshot.round.consecutiveFailures}/${snapshot.round.maxFailures}。`,
+    '仓库中的工程、验收、安全和权限约束始终有效。但如果某条 Skill/tool 指令明确限定为其他 Controller host/runtime（例如“仅 Codex 使用/发现的 Skill”），它不是 ChatGPT 当前 round 的硬 capability gate，也不得仅为了满足该 host wording 而 delegate；应使用当前 ChatGPT/Forge 已有能力完成同一工程目标，或基于真实缺失能力提交精确 blocker。',
+    record.authorityId
+      ? `本轮 durable controller authority 为 controller_authority_id=${record.authorityId}。在 controller_claim、plan_accept_step、continue、verify、review、finalize、stop、controller_release 以及 terminal-successor start 中，必须保持同一个 controller_authority_id 与 relay_scope_id=${record.relayScopeId}。Frozen client 第一次 claim 使用 controller.round:controller_claim:${record.authorityId}:${record.relayScopeId}；plan_accept_step、continue、verify、finalize、stop、controller_release 使用 controller.round:<operation>:${record.authorityId}:${record.relayScopeId} authority；review 必须使用 controller.round:review:<approved|changes_required|blocked>:${record.authorityId}:${record.relayScopeId}，并通过 reason 携带 review rationale。若 terminal-successor start 的旧 schema 缺 work_kind/engineering_preconditions/round 字段，使用 bounded semantic start compatibility carrier。绝不能用 transport session id 或其他 Work/conversation authority 替代。`
+      : '这是没有 controller authority capability 的 legacy relay record；只能沿用已经 claim 的 controller lineage，直到显式恢复本轮。',
+    ...(snapshot.recoveryReason
+      ? ['上一轮 ChatGPT 在 liveness grace 到期前没有提交显式 disposition。必须重新读取 durable state，并显式关闭本轮。']
+      : []),
+    terminalOriginGuidance
+      ? `terminal predecessor 必须在显式 successor start 完成 mechanical bind 后，再显式提交一次 continue_immediately；得到 pending_release 后仅释放 predecessor。若没有可执行 successor，则按最新 Plan/Requirement 事实使用 wait、带 active Handoff 的 wait_for_user 或 goal_complete。`
+      : `如果 Requirement/Goal 需要下一个 controller round，在释放 Work 前提交 continue_immediately，并带 relay_scope_id=${record.relayScopeId}。否则使用 wait、带 active Handoff 的 wait_for_user，或 goal_complete。Frozen MCP client 可使用 controller.disposition:<disposition>:${record.relayScopeId}。`,
+    '本轮结束协议是强制的：在向用户输出本轮最终回复之前，必须先提交且仅提交一次 semantic disposition，并完成 controller_release；不得只报告“继续中”“下一步继续”或输出进度后结束本轮。',
+    '如果最新 durable state 表明 Requirement/Goal 尚有可执行工作，且不存在真实 external blocker、active Handoff 或必须由用户决定的边界，则必须选择 continue_immediately。wait 只用于真实等待条件；wait_for_user 必须绑定 active Handoff；goal_complete 只用于 Requirement/Goal 已语义完成。',
+    '提交 continue_immediately 后必须立即 controller_release 当前 Work。controller_release 是立即续跑的 canonical trigger：Forge 将通过现有 ChatGPT launcher 复用 durable conversation binding 并投递下一 ControllerRound prompt。正常连续推进不得依赖用户再次发送“继续”，也不得用 interval schedule 代替该即时 relay；schedule 只能作为故障恢复/watchdog。',
+    'Forge 不得自行推断 semantic next step。现有 Work ownership、Handoff authority 与 external-effect authorization 始终是权威。',
+  ].join('\n');
+}
+
+/** ChatGPT adapter continuity proof; Kernel only sees the opaque binding id. */
+export function chatgptControllerRoundBindingAuthorizesRecovery(
+  record: ControllerRoundRelayRecord | undefined,
+  binding: ChatgptWorkConversationBinding | undefined,
+): boolean {
+  if (record?.controllerType !== 'chatgpt' || record.status !== 'dispatched' || !record.bindingId || !binding) return false;
+  if (binding.bindingId !== record.bindingId || !binding.latestBrowserSessionId) return false;
+  try { return hasChatgptConversationIdentity(binding.conversationUrl); } catch { return false; }
+}

package/adapters/chatgpt/controller-round-settlement-store.ts

@@ -0,0 +1,45 @@
+import { withControllerLock } from '../../src/cli/repositories/locks';
+import { readControlPlaneRecord, writeControlPlaneRecord } from '../../src/runtime/control-plane/persistence/sqlite-store';
+
+// Resource-cleanup evidence only. Provider dispatch authority is ControllerRoundRelayRecord.lifecycleStage/providerDispatchReceiptId.
+const NAMESPACE = 'chatgpt_controller_round_settlement';
+
+export type ChatgptControllerRoundSettlementStatus =
+  | 'round_open'
+  | 'retained_for_immediate_continuation'
+  | 'closed'
+  | 'preserved_user_owned'
+  | 'session_closed'
+  | 'failed';
+
+/** Browser/tab resource settlement evidence after a semantic ControllerRound; never proof that a provider prompt was dispatched. */
+export interface ChatgptControllerRoundSettlement {
+  schemaVersion: 1;
+  repoId: string;
+  workId: string;
+  relayScopeId: string;
+  status: ChatgptControllerRoundSettlementStatus;
+  recordedAt: string;
+  error?: string;
+}
+
+export function recordChatgptControllerRoundSettlement(
+  options: { controllerHome: string; repoId: string; now?: () => string },
+  input: { workId: string; relayScopeId: string; status: ChatgptControllerRoundSettlementStatus; error?: string },
+): ChatgptControllerRoundSettlement {
+  const key = `${input.workId}:${input.relayScopeId}`;
+  return withControllerLock(options.controllerHome, { scope: 'task', repoId: options.repoId, taskId: `chatgpt-round-settlement-${input.workId}` }, `chatgpt-round-settlement:${key}`, () => {
+    const existing = readControlPlaneRecord<ChatgptControllerRoundSettlement>(options.controllerHome, NAMESPACE, options.repoId, key);
+    const value: ChatgptControllerRoundSettlement = {
+      schemaVersion: 1,
+      repoId: options.repoId,
+      workId: input.workId,
+      relayScopeId: input.relayScopeId,
+      status: input.status,
+      recordedAt: options.now?.() ?? new Date().toISOString(),
+      ...(input.error?.trim() ? { error: input.error.trim().slice(0, 2_000) } : {}),
+    };
+    writeControlPlaneRecord(options.controllerHome, { namespace: NAMESPACE, scope: options.repoId, key, schemaVersion: 1, value, action: 'chatgpt_controller_round_settlement', expectedRevision: existing?.revision ?? null });
+    return value;
+  });
+}

package/adapters/chatgpt/provider-delivery.ts

@@ -0,0 +1,113 @@
+import { createHash } from 'crypto';
+
+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 CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN = 'CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN';
+
+export type ChatgptAutomationReasoning = 'medium' | 'high' | 'xhigh';
+export type ChatgptAutomationTabPolicy = 'auto' | 'reuse' | 'new';
+export type ChatgptAutomationTabCleanupStatus = 'closed' | 'preserved_user_owned' | 'session_closed' | 'failed';
+
+export type ChatgptProviderFailureDisposition = 'outcome_unknown' | 'wait_for_user' | 'failed';
+export type ChatgptProviderDeliveryStatus = 'dispatch_confirmed' | ChatgptProviderFailureDisposition;
+export type ChatgptProviderKind = 'controller-browser' | 'chatgpt-bridge';
+
+export class ChatgptProviderDeliveryError extends Error {
+  readonly code: string;
+  readonly conversationUrl?: string;
+
+  constructor(code: string, message: string, options: { conversationUrl?: string } = {}) {
+    super(message);
+    this.name = 'ChatgptProviderDeliveryError';
+    this.code = code;
+    this.conversationUrl = options.conversationUrl;
+  }
+}
+
+export interface ChatgptProviderErrorEvidence {
+  code: string;
+  message: string;
+  conversationUrl?: string;
+}
+
+export interface ChatgptProviderDeliveryInput {
+  controllerHome: string;
+  repoId: string;
+  repoRoot: string;
+  workId: string;
+  prompt: string;
+  browserSessionId: string;
+  targetUrl: string;
+  model: string;
+  reasoning: 'medium' | 'high' | 'xhigh';
+  timeoutMs?: number;
+}
+
+export interface ChatgptProviderDeliveryResult {
+  status: ChatgptProviderDeliveryStatus;
+  provider: ChatgptProviderKind;
+  browserSessionId: string;
+  conversationUrl?: string;
+  executionPreferenceVerified: boolean;
+  error?: { code: string; message: string };
+}
+
+/** Provider delivery owns browser/bridge mutation and confirmation, never semantic Work authority. */
+export interface ChatgptProviderDeliveryHost {
+  dispatch(input: ChatgptProviderDeliveryInput): Promise<ChatgptProviderDeliveryResult>;
+}
+
+const CHATGPT_WAIT_FOR_USER_MARKERS = [
+  'LOGIN_REQUIRED',
+  'AUTH_REQUIRED',
+  'AUTHENTICATION_REQUIRED',
+  'USER_ACTION_REQUIRED',
+  'PERMISSION_REQUIRED',
+  'CONSENT_REQUIRED',
+] as const;
+
+/** Classify provider failure without turning delivery/session details into Kernel authority. */
+export function classifyChatgptProviderFailure(
+  code?: string,
+  message?: string,
+): ChatgptProviderFailureDisposition {
+  const normalized = `${code ?? ''}\n${message ?? ''}`.toUpperCase();
+  if (normalized.includes('OUTCOME_UNKNOWN') || normalized.includes('SUBMISSION_NOT_CONFIRMED')) return 'outcome_unknown';
+  if (CHATGPT_WAIT_FOR_USER_MARKERS.some((marker) => normalized.includes(marker))) return 'wait_for_user';
+  return 'failed';
+}
+
+
+export function chatgptProviderDispatchReceiptId(input: {
+  repoId: string;
+  workId: string;
+  relayScopeId: string;
+  controllerAuthorityId: string;
+  provider: ChatgptProviderKind;
+}): string {
+  const digest = createHash('sha256').update([
+    input.repoId,
+    input.workId,
+    input.relayScopeId,
+    input.controllerAuthorityId,
+    input.provider,
+  ].join('\n')).digest('hex').slice(0, 32);
+  return `chatgpt-dispatch:${digest}`;
+}
+
+export function chatgptProviderError(error: unknown, fallbackCode: string): ChatgptProviderErrorEvidence {
+  const message = error instanceof Error ? error.message : String(error);
+  const code = error instanceof ChatgptProviderDeliveryError
+    ? error.code
+    : error instanceof Error && error.message.includes(':')
+      ? error.message.split(':', 1)[0]
+      : fallbackCode;
+  return {
+    code,
+    message,
+    ...(error instanceof ChatgptProviderDeliveryError && error.conversationUrl
+      ? { conversationUrl: error.conversationUrl }
+      : {}),
+  };
+}

package/adapters/chatgpt/work-conversation-binding-store.ts

@@ -0,0 +1,192 @@
+import { withControllerLock } from '../../src/cli/repositories/locks';
+import { readControlPlaneRecord, writeControlPlaneRecord } from '../../src/runtime/control-plane/persistence/sqlite-store';
+
+const NAMESPACE = 'chatgpt_work_conversation_binding';
+
+export interface ChatgptWorkConversationBinding {
+  schemaVersion: 1;
+  repoId: string;
+  workId: string;
+  /** Stable opaque ControllerBinding adapterRef exposed to Kernel. */
+  bindingId: string;
+  conversationUrl: string;
+  conversationId: string;
+  localAlias: string;
+  latestBrowserSessionId?: string;
+  /** Explicit controller-scoped Browser grants reusable by scheduled delivery. */
+  authorizationGrantRefs?: string[];
+  createdAt: string;
+  updatedAt: string;
+  lastContinuedAt?: string;
+}
+
+export interface ChatgptWorkBindingStoreOptions {
+  controllerHome: string;
+  repoId: string;
+  now?: () => string;
+}
+
+export function chatgptControllerBindingId(repoId: string, workId: string): string {
+  return `chatgpt:${repoId}:${workId}`;
+}
+
+function nowIso(options: ChatgptWorkBindingStoreOptions): string {
+  return options.now?.() ?? new Date().toISOString();
+}
+
+export function parseChatgptConversationIdentity(value: string): { conversationUrl: string; conversationId: string } {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error('CHATGPT_WORK_CONVERSATION_URL_INVALID');
+  }
+  if (url.protocol !== 'https:' || !['chatgpt.com', 'www.chatgpt.com', 'chat.openai.com'].includes(url.hostname)) {
+    throw new Error('CHATGPT_WORK_CONVERSATION_URL_INVALID');
+  }
+  const parts = url.pathname.split('/').filter(Boolean);
+  const c = parts.lastIndexOf('c');
+  const conversationId = c >= 0 ? parts[c + 1]?.trim() : undefined;
+  if (!conversationId) throw new Error('CHATGPT_WORK_CONVERSATION_ID_MISSING');
+  url.protocol = 'https:';
+  url.hostname = 'chatgpt.com';
+  url.search = '';
+  url.hash = '';
+  return { conversationUrl: url.toString(), conversationId };
+}
+
+export function hasChatgptConversationIdentity(value: string): boolean {
+  try {
+    parseChatgptConversationIdentity(value);
+    return true;
+  } catch (error) {
+    // ChatGPT root and Project URLs are valid launch seeds, but they are not
+    // durable conversation identities. Persist only the /c/<id> URL observed
+    // after the browser confirms submission.
+    if (error instanceof Error && error.message === 'CHATGPT_WORK_CONVERSATION_ID_MISSING') return false;
+    throw error;
+  }
+}
+
+function record(options: ChatgptWorkBindingStoreOptions, workId: string) {
+  return readControlPlaneRecord<ChatgptWorkConversationBinding>(
+    options.controllerHome,
+    NAMESPACE,
+    options.repoId,
+    workId,
+  );
+}
+
+export function getChatgptWorkConversationBinding(
+  options: ChatgptWorkBindingStoreOptions,
+  workId: string,
+): ChatgptWorkConversationBinding | undefined {
+  const value = record(options, workId)?.value;
+  return value ? { ...value, bindingId: value.bindingId || chatgptControllerBindingId(options.repoId, workId) } : undefined;
+}
+
+export function rebindChatgptWorkConversation(
+  options: ChatgptWorkBindingStoreOptions,
+  input: {
+    workId: string;
+    previousConversationId: string;
+    conversationUrl: string;
+    latestBrowserSessionId?: string;
+    authorizationGrantRefs?: readonly string[];
+    localAlias?: string;
+  },
+): ChatgptWorkConversationBinding {
+  if (!input.workId.trim()) throw new Error('CHATGPT_WORK_BINDING_WORK_REQUIRED');
+  if (!input.previousConversationId.trim()) throw new Error('CHATGPT_WORK_REBIND_PREVIOUS_CONVERSATION_REQUIRED');
+  const identity = parseChatgptConversationIdentity(input.conversationUrl);
+  return withControllerLock(
+    options.controllerHome,
+    { scope: 'task', repoId: options.repoId, taskId: `chatgpt-work-binding-${input.workId}` },
+    `chatgpt-work-rebind:${input.workId}`,
+    () => {
+      const existing = record(options, input.workId);
+      if (!existing) throw new Error(`CHATGPT_WORK_CONVERSATION_BINDING_NOT_FOUND: ${input.workId}`);
+      if (existing.value.conversationId !== input.previousConversationId.trim()) {
+        throw new Error(`CHATGPT_WORK_CONVERSATION_REBIND_STALE: ${input.workId}:${existing.value.conversationId}`);
+      }
+      const now = nowIso(options);
+      const binding: ChatgptWorkConversationBinding = {
+        schemaVersion: 1,
+        repoId: options.repoId,
+        workId: input.workId,
+        bindingId: chatgptControllerBindingId(options.repoId, input.workId),
+        conversationUrl: identity.conversationUrl,
+        conversationId: identity.conversationId,
+        localAlias: (input.localAlias?.trim() || existing.value.localAlias).slice(0, 180),
+        latestBrowserSessionId: input.latestBrowserSessionId ?? existing.value.latestBrowserSessionId,
+        authorizationGrantRefs: [...new Set((input.authorizationGrantRefs ?? existing.value.authorizationGrantRefs ?? []).map((ref) => ref.trim()).filter(Boolean))],
+        createdAt: existing.value.createdAt,
+        updatedAt: now,
+        lastContinuedAt: now,
+      };
+      writeControlPlaneRecord(options.controllerHome, {
+        namespace: NAMESPACE,
+        scope: options.repoId,
+        key: input.workId,
+        schemaVersion: 1,
+        value: binding,
+        action: 'chatgpt_work_conversation_rebind',
+        expectedRevision: existing.revision,
+      });
+      return binding;
+    },
+  );
+}
+
+export function bindChatgptWorkConversation(
+  options: ChatgptWorkBindingStoreOptions,
+  input: {
+    workId: string;
+    conversationUrl: string;
+    latestBrowserSessionId?: string;
+    authorizationGrantRefs?: readonly string[];
+    localAlias?: string;
+  },
+): ChatgptWorkConversationBinding {
+  if (!input.workId.trim()) throw new Error('CHATGPT_WORK_BINDING_WORK_REQUIRED');
+  const identity = parseChatgptConversationIdentity(input.conversationUrl);
+  return withControllerLock(
+    options.controllerHome,
+    { scope: 'task', repoId: options.repoId, taskId: `chatgpt-work-binding-${input.workId}` },
+    `chatgpt-work-binding:${input.workId}`,
+    () => {
+      const existing = record(options, input.workId);
+      if (existing && existing.value.conversationId !== identity.conversationId) {
+        throw new Error(`CHATGPT_WORK_CONVERSATION_REBIND_REQUIRED: ${input.workId}:${existing.value.conversationId}`);
+      }
+      const now = nowIso(options);
+      const localAlias = input.localAlias?.trim()
+        || existing?.value.localAlias
+        || `Forge · ${options.repoId} · ${input.workId} · ${identity.conversationId.slice(0, 8)}`;
+      const binding: ChatgptWorkConversationBinding = {
+        schemaVersion: 1,
+        repoId: options.repoId,
+        workId: input.workId,
+        bindingId: chatgptControllerBindingId(options.repoId, input.workId),
+        conversationUrl: identity.conversationUrl,
+        conversationId: identity.conversationId,
+        localAlias: localAlias.slice(0, 180),
+        latestBrowserSessionId: input.latestBrowserSessionId ?? existing?.value.latestBrowserSessionId,
+        authorizationGrantRefs: [...new Set((input.authorizationGrantRefs ?? existing?.value.authorizationGrantRefs ?? []).map((ref) => ref.trim()).filter(Boolean))],
+        createdAt: existing?.value.createdAt ?? now,
+        updatedAt: now,
+        lastContinuedAt: now,
+      };
+      writeControlPlaneRecord(options.controllerHome, {
+        namespace: NAMESPACE,
+        scope: options.repoId,
+        key: input.workId,
+        schemaVersion: 1,
+        value: binding,
+        action: existing ? 'chatgpt_work_conversation_continue' : 'chatgpt_work_conversation_bind',
+        expectedRevision: existing?.revision ?? null,
+      });
+      return binding;
+    },
+  );
+}

package/adapters/chatgpt/wsl-bridge-delivery-host.ts

@@ -0,0 +1,63 @@
+import { runBridgeProvider } from '../../src/cli/chatgpt-browser/bridge-provider';
+import { controllerSystemRoot } from '../../src/cli/repositories/controller-home';
+import {
+  classifyChatgptProviderFailure,
+  type ChatgptProviderDeliveryHost,
+} from './provider-delivery';
+
+/** WSL bridge delivery host. Windows Chrome is transport; this adapter returns the same dispatch semantics as native Browser. */
+export function createChatgptWslBridgeDeliveryHost(): ChatgptProviderDeliveryHost {
+  return {
+    async dispatch(input) {
+      try {
+        const bridgeRoot = controllerSystemRoot(input.controllerHome);
+        const bridged = await runBridgeProvider({
+          repoRoot: bridgeRoot,
+          prompt: input.prompt,
+          provider: 'bridge',
+          chatgptUrl: input.targetUrl,
+          timeoutMs: input.timeoutMs ?? 60_000,
+          dispatchOnly: true,
+        }, {
+          prompt: input.prompt,
+          rendered: input.prompt,
+          files: [],
+          followups: [],
+          totalChars: input.prompt.length,
+        });
+        if (bridged.status !== 'completed') {
+          const code = bridged.error?.code ?? 'CHATGPT_BRIDGE_DISPATCH_FAILED';
+          const message = bridged.error?.message ?? bridged.output;
+          return {
+            status: classifyChatgptProviderFailure(code, message),
+            provider: 'chatgpt-bridge',
+            browserSessionId: input.browserSessionId,
+            conversationUrl: bridged.conversationUrl ?? input.targetUrl,
+            executionPreferenceVerified: false,
+            error: { code, message },
+          };
+        }
+        return {
+          status: 'dispatch_confirmed',
+          provider: 'chatgpt-bridge',
+          browserSessionId: input.browserSessionId,
+          conversationUrl: bridged.conversationUrl ?? input.targetUrl,
+          executionPreferenceVerified: false,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = error instanceof Error && error.message.includes(':')
+          ? error.message.split(':', 1)[0]
+          : 'CHATGPT_BRIDGE_DISPATCH_FAILED';
+        return {
+          status: classifyChatgptProviderFailure(code, message),
+          provider: 'chatgpt-bridge',
+          browserSessionId: input.browserSessionId,
+          conversationUrl: input.targetUrl,
+          executionPreferenceVerified: false,
+          error: { code, message },
+        };
+      }
+    },
+  };
+}