@moretea-labs/forge 1.8.1 → 1.8.2

package/adapters/computer/chatgpt-extension-target.ts

@@ -102,6 +102,9 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
   private readonly providerStates = new Map<string, ProviderState>();
   private readonly pending = new Map<string, PendingCommand>();
   private readonly queues = new Map<string, string[]>();
+  // Process-local physical-operation singleflight, not a second tab lifecycle
+  // authority. Exact Surface binding/CAS remains the only durable owner.
+  private readonly retiring = new Map<string, Promise<boolean>>();
 
   constructor(
     private readonly controllerHome: string,
@@ -183,11 +186,15 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
 
   private selectProviderInstance(preferredInstanceId?: string): { instanceId?: string; ambiguous: boolean } {
     const fresh = this.freshProviders();
-    if (preferredInstanceId && fresh.some(([instanceId]) => instanceId === preferredInstanceId)) {
-      return { instanceId: preferredInstanceId, ambiguous: false };
+    if (preferredInstanceId) {
+      // A disconnected profile is unavailable, not permission to switch to
+      // the only other signed-in (or signed-out) Chrome instance.
+      return { ...(fresh.some(([instanceId]) => instanceId === preferredInstanceId)
+        ? { instanceId: preferredInstanceId } : {}), ambiguous: false };
     }
-    const current = fresh.filter(([, state]) => state.heartbeat.conversations.some((conversation) => conversation.isCurrent));
-    if (current.length === 1) return { instanceId: current[0]![0], ambiguous: false };
+    // Foreground tab is not a durable browser-principal binding. If more
+    // than one Extension instance is connected, require a known pin instead
+    // of guessing which profile should receive a new Supervisor effect.
     if (fresh.length === 1) return { instanceId: fresh[0]![0], ambiguous: false };
     return { ambiguous: fresh.length > 1 };
   }
@@ -239,7 +246,20 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
     const record = this.upsert(identity);
     const normalized = normalizeBinding(binding, instanceId);
     if (!normalized) return record;
-    return await this.authority.withSurfaceLease(this.controllerHome, record.targetId, async (lease) => lease.bind(normalized));
+    return await this.authority.withSurfaceLease(this.controllerHome, record.targetId, async (lease) => {
+      const previous = lease.current().providerBinding;
+      // Heartbeat inventory omits the Forge-create token. Carry it forward only
+      // for the same exact physical attachment; never transfer it to a new tab.
+      const sameAttachment = previous?.providerId === normalized.providerId
+        && previous.providerSessionId === normalized.providerSessionId
+        && previous.browserProduct === normalized.browserProduct
+        && previous.windowId === normalized.windowId
+        && previous.tabId === normalized.tabId;
+      return lease.bind({
+        ...normalized,
+        ...(normalized.ownerToken ? {} : sameAttachment && previous?.ownerToken ? { ownerToken: previous.ownerToken } : {}),
+      });
+    });
   }
 
   private target(identity: ComputerChatgptTargetIdentity, record: ComputerSurfaceTarget, instanceId: string): ComputerChatgptConversationTarget {
@@ -250,7 +270,19 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
         const response = await this.submit(instanceId, { kind: 'observe', identity, ...(record.providerBinding ? { providerBinding: record.providerBinding } : {}), ...(options ? { options } : {}) });
         if (!response.result) throw new Error(response.claimed ? 'COMPUTER_CHATGPT_EXTENSION_OBSERVATION_OUTCOME_UNKNOWN' : 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED');
         if (response.result.kind === 'observation') {
-          if (response.result.providerBinding) await this.bindAsync(identity, response.result.providerBinding, instanceId);
+          if (response.result.providerBinding) {
+            const observed = normalizeBinding(response.result.providerBinding, instanceId);
+            const saved = this.authority.getSurface(this.controllerHome, record.targetId)?.providerBinding;
+            // A newer observedAt is not a new physical binding. Normal reads
+            // must not rewrite the Surface and its binding indexes on every poll.
+            if (!observed || !saved || saved.providerId !== observed.providerId
+              || saved.providerSessionId !== observed.providerSessionId
+              || saved.browserProduct !== observed.browserProduct
+              || saved.windowId !== observed.windowId || saved.tabId !== observed.tabId
+              || (observed.ownerToken && saved.ownerToken !== observed.ownerToken)) {
+              await this.bindAsync(identity, response.result.providerBinding, instanceId);
+            }
+          }
           return response.result.observation;
         }
         if (response.result.kind === 'failed') throw new Error(response.result.code);
@@ -259,29 +291,30 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
       prepare: async (prompt, options) => {
         const response = await this.submit(instanceId, { kind: 'prepare', identity, ...(record.providerBinding ? { providerBinding: record.providerBinding } : {}), prompt,
           ...(options?.mode ? { mode: options.mode } : {}),
-          ...(options?.reasoning ? { reasoning: options.reasoning } : {}),
         });
         if (!response.result) return { ready: false, reasonCode: response.claimed
           ? 'COMPUTER_CHATGPT_EXTENSION_PREPARE_OUTCOME_UNKNOWN' : 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED' };
-        if (response.result.kind === 'prepared') return response.result.ready
-          ? { ready: true } : { ready: false, reasonCode: response.result.reasonCode };
+        if (response.result.kind === 'prepared') {
+          if (!response.result.ready) return { ready: false, reasonCode: response.result.reasonCode };
+          return { ready: true };
+        }
         return { ready: false, reasonCode: response.result.kind === 'failed'
           ? response.result.code : 'COMPUTER_CHATGPT_EXTENSION_PREPARE_INVALID' };
       },
       dispatch: async (prompt, options) => {
-        const response = await this.submit(instanceId, { kind: 'dispatch', identity, ...(record.providerBinding ? { providerBinding: record.providerBinding } : {}), prompt, ...(options?.mode ? { mode: options.mode } : {}), ...(options?.reasoning ? { reasoning: options.reasoning } : {}) });
+        const response = await this.submit(instanceId, { kind: 'dispatch', identity, ...(record.providerBinding ? { providerBinding: record.providerBinding } : {}), prompt, ...(options?.mode ? { mode: options.mode } : {}) });
         if (!response.result) {
           return response.claimed
             ? { mutation: 'attempted' as const }
             : { mutation: 'not_attempted' as const, reasonCode: 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED' };
         }
         if (response.result.kind === 'dispatch') {
-          return response.result.mutation === 'attempted'
-            ? { mutation: 'attempted' as const, ...(response.result.confirmed === undefined ? {} : { confirmed: response.result.confirmed }), ...(response.result.reasoningVerified ? { reasoningVerified: response.result.reasoningVerified } : {}) }
-            : { mutation: 'not_attempted' as const, reasonCode: response.result.reasonCode };
+          if (response.result.mutation === 'attempted') return { mutation: 'attempted' as const, ...(response.result.confirmed === undefined ? {} : { confirmed: response.result.confirmed }) };
+          if (response.result.mutation === 'not_attempted') return { mutation: 'not_attempted' as const, reasonCode: response.result.reasonCode };
         }
-        if (response.result.kind === 'failed') return { mutation: 'not_attempted' as const, reasonCode: response.result.code };
-        return { mutation: 'not_attempted' as const, reasonCode: 'COMPUTER_CHATGPT_EXTENSION_DISPATCH_INVALID' };
+        // Only a typed dispatch/not_attempted result proves no Send click. A
+        // generic failure or wrong response kind cannot authorize another send.
+        return { mutation: 'attempted' as const, confirmed: false };
       },
     };
   }
@@ -299,21 +332,44 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
     return { conversations: [...byConversationId.values()], complete: true, unavailableProviders: [] };
   }
 
-  async ensureExact(identity: ComputerChatgptConversationIdentity): Promise<ComputerChatgptTargetResult> {
+  async ensureExact(identity: ComputerChatgptConversationIdentity, options: { createIfMissing?: boolean } = {}): Promise<ComputerChatgptTargetResult> {
+    const preferredInstanceId = this.preferredProviderInstance(identity);
     const fresh = this.freshProviders();
-    if (fresh.length === 0) return failure('COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED', { failoverSafe: true });
-    const exact = fresh.flatMap(([instanceId, state]) => state.heartbeat.conversations
+    if (fresh.length === 0 || (preferredInstanceId && !fresh.some(([instanceId]) => instanceId === preferredInstanceId))) {
+      return failure('COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED', { failoverSafe: !preferredInstanceId });
+    }
+    const exact = fresh.filter(([instanceId]) => !preferredInstanceId || instanceId === preferredInstanceId)
+      .flatMap(([instanceId, state]) => state.heartbeat.conversations
       .filter((entry) => entry.conversationId === identity.conversationId)
       .map((entry) => ({ instanceId, entry })));
-    if (exact.length > 1) return failure('COMPUTER_CHATGPT_EXTENSION_EXACT_TARGET_AMBIGUOUS', { failoverSafe: false });
-    if (exact.length === 1) {
-      const candidate = exact[0]!;
+    // Multiple tabs can show one conversation. Prefer the existing exact
+    // Computer binding over heartbeat focus or an arbitrary matching tab.
+    const binding = this.authority.findSurfaceByStableIdentity(this.controllerHome, stableIdentity(identity))?.providerBinding;
+    let candidates = exact;
+    if (binding?.providerId === PROVIDER_ID && binding.windowId && binding.tabId) {
+      const bound = exact.filter(({ instanceId, entry }) => instanceId === binding.providerSessionId
+        && entry.providerBinding?.tabId === binding.tabId
+        && (!binding.browserProduct || entry.providerBinding?.browserProduct === binding.browserProduct));
+      // Chrome restart replaces physical tab IDs, not the profile principal or
+      // conversation identity. A unique exact tab observed by that SAME live
+      // provider may replace an absent pin through the Surface lease below.
+      // Never choose between multiple matching tabs or switch browser profiles.
+      const replacement = exact.length === 1 && exact[0]!.instanceId === binding.providerSessionId
+        && (!binding.browserProduct || exact[0]!.entry.providerBinding?.browserProduct === binding.browserProduct)
+        ? exact : [];
+      candidates = bound.length ? bound : replacement;
+    }
+    // A stale binding must not turn two observed exact tabs into a third tab.
+    if (exact.length > 1 && candidates.length !== 1) return failure('COMPUTER_CHATGPT_EXTENSION_EXACT_TARGET_AMBIGUOUS', { failoverSafe: false });
+    if (candidates.length === 1) {
+      const candidate = candidates[0]!;
+      if (!candidate.entry.providerBinding) return failure('COMPUTER_CHATGPT_EXTENSION_PHYSICAL_TAB_UNVERIFIED', { failoverSafe: false });
       const record = await this.bindAsync(identity, candidate.entry.providerBinding, candidate.instanceId);
       const target = this.target(identity, record, candidate.instanceId);
       try {
         const observation = await target.observe({ includeUserHistory: false, includePageText: false });
         if (!conversationContentAvailable(observation)) {
-          return failure('COMPUTER_CHATGPT_CONVERSATION_CONTENT_UNAVAILABLE', { failoverSafe: true });
+          return failure('COMPUTER_CHATGPT_CONVERSATION_CONTENT_UNAVAILABLE', { failoverSafe: false });
         }
         return { state: 'ready', target, observation };
       } catch (error) {
@@ -321,15 +377,49 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
           error instanceof Error && error.message.trim()
             ? error.message.trim()
             : 'COMPUTER_CHATGPT_EXTENSION_OBSERVATION_UNAVAILABLE',
-          { failoverSafe: true },
+          { failoverSafe: false },
         );
       }
     }
-    const selected = this.selectProviderInstance(this.preferredProviderInstance(identity));
+    // A heartbeat is an inventory hint, not the exact-target authority.
+    // When it has no match, let the SAME live Chrome instance perform one
+    // read-only physical-tab lookup. This does not create a tab or replay Send;
+    // the provider refuses ambiguous matches and drifted pinned tabs.
+    if (options.createIfMissing === false) {
+      const selected = this.selectProviderInstance(preferredInstanceId);
+      if (!selected.instanceId) return failure(
+        selected.ambiguous ? 'COMPUTER_CHATGPT_EXTENSION_PROVIDER_INSTANCE_AMBIGUOUS' : 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED',
+        { failoverSafe: false },
+      );
+      const response = await this.submit(selected.instanceId, { kind: 'observe', identity,
+        ...(binding?.providerId === PROVIDER_ID ? { providerBinding: binding } : {}),
+        options: { includeUserHistory: false, includePageText: false },
+      });
+      if (!response.result) return failure('COMPUTER_CHATGPT_EXTENSION_OBSERVATION_UNAVAILABLE', { failoverSafe: false });
+      if (response.result.kind === 'observation') {
+        const { observation, providerBinding } = response.result;
+        let exactUrl = false;
+        try {
+          const parsed = new URL(observation.url);
+          exactUrl = parsed.origin === 'https://chatgpt.com'
+            && parsed.pathname.endsWith(`/c/${identity.conversationId}`);
+        } catch { /* Never bind an unparseable or changed conversation target. */ }
+        if (!exactUrl || !providerBinding) return failure('COMPUTER_CHATGPT_EXTENSION_TARGET_IDENTITY_UNVERIFIED', { failoverSafe: false });
+        if (!conversationContentAvailable(observation)) return failure('COMPUTER_CHATGPT_CONVERSATION_CONTENT_UNAVAILABLE', { failoverSafe: false });
+        const record = await this.bindAsync(identity, providerBinding, selected.instanceId);
+        return { state: 'ready', target: this.target(identity, record, selected.instanceId), observation };
+      }
+      return failure(response.result.kind === 'failed'
+        ? response.result.code === 'COMPUTER_CHATGPT_EXTENSION_TARGET_MISSING'
+          ? 'COMPUTER_CHATGPT_EXTENSION_EXACT_TARGET_ABSENT_READ_ONLY'
+          : response.result.code
+        : 'COMPUTER_CHATGPT_EXTENSION_OBSERVATION_INVALID', { failoverSafe: false });
+    }
+    const selected = this.selectProviderInstance(preferredInstanceId);
     if (!selected.instanceId) {
       return failure(
         selected.ambiguous ? 'COMPUTER_CHATGPT_EXTENSION_PROVIDER_INSTANCE_AMBIGUOUS' : 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED',
-        { failoverSafe: !selected.ambiguous },
+        { failoverSafe: !selected.ambiguous && !preferredInstanceId },
       );
     }
     const previous = this.authority.findSurfaceByStableIdentity(this.controllerHome, stableIdentity(identity));
@@ -338,44 +428,96 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
     });
     if (!response.result) return failure(
       response.claimed ? 'COMPUTER_CHATGPT_EXTENSION_TARGET_OPEN_OUTCOME_UNKNOWN' : 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED',
-      { failoverSafe: !response.claimed },
+      { failoverSafe: !response.claimed && !preferredInstanceId },
     );
     if (response.result.kind === 'ensured') {
+      const record = await this.bindAsync(identity, response.result.providerBinding, selected.instanceId);
       if (response.result.observation && !conversationContentAvailable(response.result.observation)) {
-        return failure('COMPUTER_CHATGPT_CONVERSATION_CONTENT_UNAVAILABLE', { failoverSafe: true });
+        return failure('COMPUTER_CHATGPT_CONVERSATION_CONTENT_UNAVAILABLE', { failoverSafe: false });
       }
-      const record = await this.bindAsync(identity, response.result.providerBinding, selected.instanceId);
       return { state: 'ready', target: this.target(identity, record, selected.instanceId), ...(response.result.observation ? { observation: response.result.observation } : {}) };
     }
-    if (response.result.kind === 'failed') return failure(response.result.code, { retryable: response.result.retryable, failoverSafe: response.result.failoverSafe !== false, humanAction: response.result.humanAction });
-    return failure('COMPUTER_CHATGPT_EXTENSION_ENSURE_INVALID', { failoverSafe: true });
+    if (response.result.kind === 'failed') {
+      if (response.result.providerBinding) await this.bindAsync(identity, response.result.providerBinding, selected.instanceId);
+      return failure(response.result.code, { retryable: response.result.retryable,
+        failoverSafe: !response.result.providerBinding && !preferredInstanceId && response.result.failoverSafe === true,
+        humanAction: response.result.humanAction });
+    }
+    return failure('COMPUTER_CHATGPT_EXTENSION_ENSURE_INVALID', { failoverSafe: false });
   }
 
-  async openBootstrap(projectUrl: string, bootstrapKey: string): Promise<ComputerChatgptTargetResult> {
+  async openBootstrap(projectUrl: string, bootstrapKey: string, recoverStalePin = true): Promise<ComputerChatgptTargetResult> {
     const identity: ComputerChatgptBootstrapIdentity = { namespace: 'chatgpt.bootstrap', bootstrapKey, projectUrl };
+    const previous = this.authority.findSurfaceByStableIdentity(this.controllerHome, stableIdentity(identity));
+    const binding = previous?.providerBinding;
+    // Existing bootstrap tab identity survives extension reconnects. A foreign
+    // provider owns its tab; extension must not create another one for the
+    // same task. Conversely, extension absence cannot authorize native tab
+    // creation while an extension-owned tab might still exist.
+    if (binding && binding.providerId !== PROVIDER_ID) {
+      return failure('COMPUTER_CHATGPT_EXTENSION_BOOTSTRAP_PROVIDER_MISMATCH', { retryable: false, failoverSafe: true });
+    }
     const selected = this.selectProviderInstance(this.preferredProviderInstance(identity));
     if (!selected.instanceId) {
       return failure(
         selected.ambiguous ? 'COMPUTER_CHATGPT_EXTENSION_PROVIDER_INSTANCE_AMBIGUOUS' : 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED',
-        { failoverSafe: !selected.ambiguous },
+        { failoverSafe: !selected.ambiguous && !binding },
       );
     }
-    // Controller is the only durable owner of a tab binding. A restarted
-    // extension uses this exact attachment instead of claiming a Project tab.
-    const previous = this.authority.findSurfaceByStableIdentity(this.controllerHome, stableIdentity(identity));
+    // Controller's exact tab attachment, not the Project URL, is recovery
+    // authority after a worker restart.
     const response = await this.submit(selected.instanceId, { kind: 'ensure', identity,
       ...(previous?.providerBinding?.providerId === PROVIDER_ID ? { providerBinding: previous.providerBinding } : {}),
     });
     if (!response.result) return failure(
       response.claimed ? 'COMPUTER_CHATGPT_EXTENSION_BOOTSTRAP_OPEN_OUTCOME_UNKNOWN' : 'COMPUTER_CHATGPT_EXTENSION_NOT_CONNECTED',
-      { failoverSafe: !response.claimed },
+      { failoverSafe: !response.claimed && !binding },
     );
     if (response.result.kind === 'ensured') {
       const record = await this.bindAsync(identity, response.result.providerBinding, selected.instanceId);
       return { state: 'ready', target: this.target(identity, record, selected.instanceId), ...(response.result.observation ? { observation: response.result.observation } : {}) };
     }
-    if (response.result.kind === 'failed') return failure(response.result.code, { retryable: response.result.retryable, failoverSafe: response.result.failoverSafe !== false, humanAction: response.result.humanAction });
-    return failure('COMPUTER_CHATGPT_EXTENSION_BOOTSTRAP_INVALID', { failoverSafe: true });
+    if (response.result.kind === 'failed') {
+      if (response.result.providerBinding) await this.bindAsync(identity, response.result.providerBinding, selected.instanceId);
+      // Only openBootstrap's pre-dispatch caller may rebuild a tab attachment.
+      // The SAME live Chrome provider must prove that the exact pinned tab is
+      // either absent or now serves a DIFFERENT Project. A reused physical tab
+      // id is not a valid target and must not permanently strand the unspent
+      // bootstrap. Never close/navigate the mismatched foreign tab. Keep the
+      // one durable target and lease/CAS-clear only its stale binding; never
+      // recover from an unknown tab-create result or switch profiles/providers.
+      if (recoverStalePin && (response.result.code === 'COMPUTER_CHATGPT_BOOTSTRAP_PINNED_TAB_MISSING'
+        || response.result.code === 'COMPUTER_CHATGPT_BOOTSTRAP_PINNED_TAB_IDENTITY_CHANGED')
+        && previous && binding?.providerId === PROVIDER_ID
+        && providerInstanceId(binding.providerSessionId) === selected.instanceId
+        && binding.windowId && binding.tabId) {
+        try {
+          await this.authority.withSurfaceLease(this.controllerHome, previous.targetId, async (lease) => {
+            const current = lease.current();
+            const attached = current.providerBinding;
+            if (current.stableIdentity.resource?.namespace !== identity.namespace
+              || current.stableIdentity.resource.key !== identity.bootstrapKey
+              || attached?.providerId !== binding.providerId
+              || attached.providerSessionId !== binding.providerSessionId
+              || attached.windowId !== binding.windowId || attached.tabId !== binding.tabId
+              || attached.browserProduct !== binding.browserProduct) {
+              throw new Error('COMPUTER_CHATGPT_BOOTSTRAP_PINNED_BINDING_CHANGED');
+            }
+            lease.clearBinding();
+          });
+        } catch {
+          return failure('COMPUTER_CHATGPT_BOOTSTRAP_PINNED_BINDING_CHANGED', { failoverSafe: false });
+        }
+        // Exactly one same-provider re-open. A claimed but unanswered tabCreate
+        // still reports outcome unknown and must never create another tab.
+        return await this.openBootstrap(projectUrl, bootstrapKey, false);
+      }
+      return failure(response.result.code, {
+        retryable: response.result.retryable, failoverSafe: response.result.failoverSafe === true && !binding && !response.result.providerBinding,
+        humanAction: response.result.humanAction,
+      });
+    }
+    return failure('COMPUTER_CHATGPT_EXTENSION_BOOTSTRAP_INVALID', { failoverSafe: false });
   }
 
   async findBySubmittedMarker(marker: string, bootstrapKey?: string, betweenObservations?: () => Promise<void>): Promise<ComputerChatgptTargetResult[]> {
@@ -388,15 +530,68 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
     })));
     await betweenObservations?.();
     const results: ComputerChatgptTargetResult[] = [];
-    const seen = new Set<string>();
+    type MarkerMatch = Extract<ComputerChatgptExtensionCommandResult, { kind: 'marker_matches' }>['matches'][number];
+    const matchesByConversation = new Map<string, Array<{ instanceId: string; match: MarkerMatch }>>();
     for (const { instanceId, response } of responses) {
       if (response.result?.kind !== 'marker_matches') continue;
       for (const match of response.result.matches) {
-        if (seen.has(match.identity.conversationId)) continue;
-        seen.add(match.identity.conversationId);
-        const record = await this.bindAsync(match.identity, match.providerBinding, instanceId);
-        results.push({ state: 'ready', target: this.target(match.identity, record, instanceId), observation: match.observation });
+        const entries = matchesByConversation.get(match.identity.conversationId) ?? [];
+        entries.push({ instanceId, match });
+        matchesByConversation.set(match.identity.conversationId, entries);
+      }
+    }
+    for (const matches of matchesByConversation.values()) {
+      const first = matches[0]!;
+      const existing = this.authority.findSurfaceByStableIdentity(this.controllerHome, stableIdentity(first.match.identity))?.providerBinding;
+      const samePhysicalBinding = (match: MarkerMatch, binding: NonNullable<typeof existing>, instanceId: string): boolean => {
+        const observed = match.providerBinding;
+        return Boolean(observed
+          && observed.providerId === binding.providerId
+          && observed.providerSessionId === binding.providerSessionId
+          && observed.browserProduct === binding.browserProduct
+          && observed.windowId === binding.windowId
+          && observed.tabId === binding.tabId
+          && observed.ownerToken === binding.ownerToken
+          && instanceId === binding.providerSessionId);
+      };
+      const existingMatch = existing?.providerId === PROVIDER_ID
+        ? matches.find(({ instanceId, match }) => samePhysicalBinding(match, existing, instanceId))
+        : undefined;
+      const bootstrap = bootstrapKey
+        ? this.authority.findSurfaceByStableIdentity(this.controllerHome, {
+            surfaceType: 'browser-tab', ownership: 'provider_owned',
+            resource: { namespace: 'chatgpt.bootstrap', key: bootstrapKey },
+          })
+        : undefined;
+      const pinned = bootstrap?.providerBinding;
+      const bootstrapMatch = pinned?.providerId === PROVIDER_ID
+        ? matches.find(({ instanceId, match }) => samePhysicalBinding(match, pinned, instanceId))
+        : undefined;
+      // A task-specific bootstrap pin outranks a conversation surface for the
+      // same conversationId. If that exact physical pin is absent, preserve the
+      // unknown outcome instead of letting another tab's marker become authority.
+      if (pinned && !bootstrapMatch) continue;
+      const candidate = pinned
+        ? bootstrapMatch
+        : existingMatch ?? (matches.length === 1 && first.match.providerBinding ? first : undefined);
+      const bootstrapMatchBinding = bootstrapMatch?.match.providerBinding;
+      const existingMatchesBootstrap = Boolean(existingMatch && bootstrapMatch && bootstrapMatchBinding
+        && existingMatch.instanceId === bootstrapMatch.instanceId
+        && samePhysicalBinding(existingMatch.match, bootstrapMatchBinding, existingMatch.instanceId));
+      // Resolve duplicate marker tabs only with an exact persisted physical pin.
+      // A bootstrap pin already owns its tab: return that target so the caller
+      // can promote it, instead of prematurely binding a second conversation
+      // Surface to the same tab and hitting COMPUTER_SURFACE_INDEX_CONFLICT.
+      if (!candidate) continue;
+      if (bootstrap && candidate === bootstrapMatch && !existingMatchesBootstrap) {
+        const metadata = bootstrap.compatibilityRecords.find((entry) => entry.namespace === 'chatgpt.target')?.value as Record<string, unknown> | undefined;
+        if (typeof metadata?.projectUrl !== 'string' || !metadata.projectUrl) continue;
+        const identity: ComputerChatgptBootstrapIdentity = { namespace: 'chatgpt.bootstrap', bootstrapKey: bootstrapKey!, projectUrl: metadata.projectUrl };
+        results.push({ state: 'ready', target: this.target(identity, bootstrap, candidate.instanceId), observation: candidate.match.observation });
+        continue;
       }
+      const record = await this.bindAsync(candidate.match.identity, candidate.match.providerBinding, candidate.instanceId);
+      results.push({ state: 'ready', target: this.target(candidate.match.identity, record, candidate.instanceId), observation: candidate.match.observation });
     }
     return results;
   }
@@ -417,6 +612,60 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
     return { state: 'ready', target: this.target(identity, record, selected.instanceId) };
   }
 
+  /** Existing Surface binding is the only retirement authority. A claimed
+   * Chrome close with missing acknowledgement is outcome-unknown: retain the
+   * exact attachment so the same owner can reconcile/retry, never make it
+   * eligible for another physical owner by clearing the index prematurely. */
+  private retirePhysicalBinding(record: ComputerSurfaceTarget, identity?: ComputerChatgptTargetIdentity): Promise<boolean> {
+    const existing = this.retiring.get(record.targetId);
+    if (existing) return existing;
+    const pending = this.retirePhysicalBindingOnce(record, identity);
+    this.retiring.set(record.targetId, pending);
+    const release = (): void => {
+      if (this.retiring.get(record.targetId) === pending) this.retiring.delete(record.targetId);
+    };
+    void pending.then(release, release);
+    return pending;
+  }
+
+  private async retirePhysicalBindingOnce(record: ComputerSurfaceTarget, identity?: ComputerChatgptTargetIdentity): Promise<boolean> {
+    const previous = record.providerBinding;
+    if (previous?.providerId !== PROVIDER_ID) return false;
+    const resource = record.stableIdentity.resource;
+    if (previous.ownerToken) {
+      const instanceId = providerInstanceId(previous.providerSessionId);
+      if (!identity || !instanceId || !this.providerIsFresh(instanceId)) return false;
+      if ([...this.pending.values()].some((entry) => 'identity' in entry.command
+        && entry.command.kind !== 'close'
+        && entry.command.identity.namespace === resource?.namespace
+        && (entry.command.identity.namespace === 'chatgpt.conversation'
+          ? entry.command.identity.conversationId === resource?.key
+          : entry.command.identity.namespace === 'chatgpt.bootstrap' && entry.command.identity.bootstrapKey === resource?.key))) return false;
+      let acknowledged = false;
+      try {
+        const response = await this.submit(instanceId, { kind: 'close', identity, providerBinding: previous });
+        acknowledged = response.result?.kind === 'closed';
+      } catch { return false; }
+      if (!acknowledged) return false;
+    }
+    // A legacy or user-attached tab has no Forge-create token: detach only,
+    // never turn a matching ChatGPT URL into permission for physical closure.
+    let cleared = false;
+    try {
+      await this.authority.withSurfaceLease(this.controllerHome, record.targetId, async (lease) => {
+        const binding = lease.current().providerBinding;
+        if (binding?.providerId !== previous.providerId
+          || binding.providerSessionId !== previous.providerSessionId
+          || binding.browserProduct !== previous.browserProduct
+          || binding.windowId !== previous.windowId || binding.tabId !== previous.tabId
+          || binding.ownerToken !== previous.ownerToken) return;
+        lease.clearBinding();
+        cleared = true;
+      });
+    } catch { return false; }
+    return cleared;
+  }
+
   async cleanup(activeResourceKeys: readonly string[]): Promise<void> {
     const active = new Set(activeResourceKeys);
     for (const record of this.authority.listAllSurfaces(this.controllerHome)) {
@@ -427,10 +676,8 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
       const identity: ComputerChatgptTargetIdentity | undefined = resource.namespace === 'chatgpt.conversation'
         ? (typeof compatibility?.canonicalUrl === 'string' ? { namespace: 'chatgpt.conversation', conversationId: resource.key, canonicalUrl: compatibility.canonicalUrl } : undefined)
         : (typeof compatibility?.projectUrl === 'string' ? { namespace: 'chatgpt.bootstrap', bootstrapKey: resource.key, projectUrl: compatibility.projectUrl } : undefined);
-      const instanceId = providerInstanceId(record.providerBinding?.providerSessionId);
-      if (identity && instanceId && this.providerIsFresh(instanceId)) await this.submit(instanceId, { kind: 'close', identity, providerBinding: record.providerBinding }).catch(() => undefined);
-      await this.authority.withSurfaceLease(this.controllerHome, record.targetId, async (lease) => { lease.clearBinding(); }).catch(() => undefined);
-      if (resource.namespace === 'chatgpt.bootstrap') this.authority.tombstoneSurface(this.controllerHome, record.targetId);
+      const cleared = await this.retirePhysicalBinding(record, identity);
+      if (cleared && resource.namespace === 'chatgpt.bootstrap') this.authority.tombstoneSurface(this.controllerHome, record.targetId);
     }
   }
 
@@ -444,9 +691,7 @@ implements ComputerChatgptConversationTargetPort, ComputerChatgptExtensionBroker
       : resource?.namespace === 'chatgpt.bootstrap' && typeof compatibility?.projectUrl === 'string'
         ? { namespace: 'chatgpt.bootstrap', bootstrapKey: resource.key, projectUrl: compatibility.projectUrl }
         : undefined;
-    const instanceId = providerInstanceId(record.providerBinding?.providerSessionId);
-    if (identity && instanceId && this.providerIsFresh(instanceId)) await this.submit(instanceId, { kind: 'close', identity }).catch(() => undefined);
-    await this.authority.withSurfaceLease(this.controllerHome, targetId, async (lease) => { lease.clearBinding(); }).catch(() => undefined);
+    if (record.providerBinding) await this.retirePhysicalBinding(record, identity);
   }
 
   async close(): Promise<void> {