@moretea-labs/forge 1.8.0 → 1.8.2

package/packages/kernel/work/ports/work-contract-store.ts

@@ -1,7 +1,10 @@
-import type { WorkContract, WorkContractStore, WorkContractStatus } from '../domain/types';
+import type { SemanticWorkState, WorkContract, WorkContractStore } from '../domain/types';
 
 export interface WorkContractStoreLocation {
   controllerHome?: string;
+  /** Canonical storage scope. Semantic Work uses the portable semantic scope; repository Work may omit this and use repoId. */
+  scopeKey?: string;
+  /** Legacy/repository execution storage scope and optional placement context. */
   repoId?: string;
   root?: string;
 }
@@ -14,5 +17,5 @@ export interface WorkContractStoreOptions extends WorkContractStoreLocation {
 export interface WorkContractPersistencePort {
   read(options: WorkContractStoreOptions): WorkContractStore;
   get(options: WorkContractStoreOptions, workId: string): WorkContract | undefined;
-  list(options: WorkContractStoreOptions & { status?: WorkContractStatus | 'active' | 'all'; limit?: number }): WorkContract[];
+  list(options: WorkContractStoreOptions & { state?: SemanticWorkState | 'active' | 'all'; limit?: number }): WorkContract[];
 }

package/packages/plugin-runtime/browser/provider-registry.ts

@@ -6,8 +6,6 @@ import {
 } from './runtime-contract';
 
 export interface BrowserRuntimeProvider<TInput, TResult> extends BrowserProviderCapabilities {
-  /** Lower values are preferred when multiple providers satisfy the same capability contract. */
-  priority: number;
   /** Availability is decided before execution; ordinary provider failures are never fallback signals. */
   supportsInput(input: TInput): boolean;
   execute(input: TInput): Promise<TResult>;
@@ -37,22 +35,6 @@ export class BrowserProviderSelectionError extends Error {
   }
 }
 
-/**
- * A typed pre-action rejection. Runtime may select another provider because this proves the action
- * was not attempted. Arbitrary provider errors are intentionally not mapped to this signal.
- */
-export class BrowserProviderUnavailableBeforeActionError extends Error {
-  readonly providerId: string;
-  readonly reason: string;
-
-  constructor(providerId: string, reason: string) {
-    super(`${providerId} unavailable before action: ${reason}`);
-    this.name = 'BrowserProviderUnavailableBeforeActionError';
-    this.providerId = providerId;
-    this.reason = reason;
-  }
-}
-
 function foregroundCompatible(
   provider: BrowserProviderCapabilities,
   requested: BrowserForegroundRequirement,
@@ -61,24 +43,23 @@ function foregroundCompatible(
 }
 
 export class BrowserProviderRegistry<TInput, TResult> {
-  private readonly providers = new Map<string, BrowserProviderState<TInput, TResult>>();
+  private state?: BrowserProviderState<TInput, TResult>;
 
   register(provider: BrowserRuntimeProvider<TInput, TResult>): void {
-    const current = this.providers.get(provider.providerId);
-    if (current) {
-      current.provider = provider;
+    if (this.state?.provider.providerId === provider.providerId) {
+      this.state.provider = provider;
       return;
     }
-    this.providers.set(provider.providerId, { provider, generation: 1 });
+    // A configuration change replaces the binding; it never accumulates candidates.
+    this.state = { provider, generation: 1 };
   }
 
   invalidate(providerId: string, reason: string): void {
-    const state = this.providers.get(providerId);
-    if (state) state.invalidatedReason = reason;
+    if (this.state?.provider.providerId === providerId) this.state.invalidatedReason = reason;
   }
 
   invalidateAll(reason: string): void {
-    for (const state of this.providers.values()) state.invalidatedReason = reason;
+    if (this.state) this.state.invalidatedReason = reason;
   }
 
   private async prepare(state: BrowserProviderState<TInput, TResult>): Promise<void> {
@@ -92,17 +73,12 @@ export class BrowserProviderRegistry<TInput, TResult> {
     input: TInput;
     requiredCapabilities: readonly BrowserProviderCapability[];
     foreground: BrowserForegroundRequirement;
-    excludedProviderIds?: ReadonlySet<string>;
   }): Promise<BrowserProviderSelection<TInput, TResult>> {
-    const candidates = [...this.providers.values()]
-      .filter(({ provider }) => !options.excludedProviderIds?.has(provider.providerId))
-      .filter(({ provider }) => provider.supportsInput(options.input))
-      .filter(({ provider }) => providerSupports(provider, options.requiredCapabilities))
-      .filter(({ provider }) => foregroundCompatible(provider, options.foreground))
-      .sort((left, right) => left.provider.priority - right.provider.priority
-        || left.provider.providerId.localeCompare(right.provider.providerId));
-
-    const selected = candidates[0];
+    const selected = this.state
+      && this.state.provider.supportsInput(options.input)
+      && providerSupports(this.state.provider, options.requiredCapabilities)
+      && foregroundCompatible(this.state.provider, options.foreground)
+      ? this.state : undefined;
     if (!selected) throw new BrowserProviderSelectionError(options.requiredCapabilities);
     await this.prepare(selected);
     return { provider: selected.provider, generation: selected.generation };

package/packages/plugin-runtime/browser/session-authority.ts

@@ -4,7 +4,8 @@ export const MAX_BROWSER_SESSION_LIST_LIMIT = 200;
 /** State-free Browser execution scope. Durable interaction identity belongs to Computer SurfaceTarget authority. */
 export interface BrowserSessionExecutionContext {
   controllerHome: string;
-  repoId: string;
+  /** Optional repository visibility/migration context; never Browser session authority. */
+  repoId?: string;
 }
 
 /** @deprecated Compatibility alias for frozen callers; this is context, not an authority capability. */

package/packages/plugin-runtime/computer/chatgpt-identity.ts

@@ -0,0 +1,24 @@
+const CHATGPT_HOSTS = new Set(['chatgpt.com', 'www.chatgpt.com', 'chat.openai.com']);
+const MAX_CONVERSATION_ID_CHARS = 256;
+
+export interface CanonicalChatgptConversationIdentity {
+  conversationUrl: string;
+  conversationId: string;
+}
+
+export function parseCanonicalChatgptConversationIdentity(value: string): CanonicalChatgptConversationIdentity {
+  let url: URL;
+  try { url = new URL(value); } catch { throw new Error('CHATGPT_CONVERSATION_URL_INVALID'); }
+  if (url.protocol !== 'https:' || !CHATGPT_HOSTS.has(url.hostname)) throw new Error('CHATGPT_CONVERSATION_URL_INVALID');
+  const parts = url.pathname.split('/').filter(Boolean);
+  const marker = parts.lastIndexOf('c');
+  if (marker < 0 || marker + 2 !== parts.length) throw new Error('CHATGPT_CONVERSATION_ID_MISSING');
+  const conversationId = parts[marker + 1]?.trim() ?? '';
+  if (!conversationId) throw new Error('CHATGPT_CONVERSATION_ID_MISSING');
+  if (conversationId.length > MAX_CONVERSATION_ID_CHARS) throw new Error('CHATGPT_CONVERSATION_ID_INVALID');
+  url.protocol = 'https:';
+  url.hostname = 'chatgpt.com';
+  url.search = '';
+  url.hash = '';
+  return { conversationUrl: url.toString(), conversationId };
+}

package/packages/plugin-runtime/computer/conversation-target.ts

@@ -0,0 +1,153 @@
+import type { ComputerSurfaceProviderBinding } from './target-authority';
+
+export interface ComputerChatgptConversationIdentity {
+  namespace: 'chatgpt.conversation';
+  conversationId: string;
+  canonicalUrl: string;
+}
+
+export interface ComputerChatgptBootstrapIdentity {
+  namespace: 'chatgpt.bootstrap';
+  bootstrapKey: string;
+  projectUrl: string;
+}
+
+export type ComputerChatgptTargetIdentity = ComputerChatgptConversationIdentity | ComputerChatgptBootstrapIdentity;
+
+export interface ComputerChatgptConversationObservation {
+  url: string;
+  title: string;
+  latestUserText: string;
+  latestAssistantResponse: string;
+  userMessages?: string[];
+  assistantMessages?: string[];
+  composerText?: string;
+  /** Read-only content-script selector attestation; undefined on older loaded scripts. */
+  composerSelectorVersion?: 'visible-single-v2';
+  /** Exact loaded content-script contract; file projection/version on disk is not a live browser attestation. */
+  composerReplacementContract?: 'exact-backed-up-project-draft-v1';
+  providerActivityText: string;
+  providerFailureText: string;
+  pageText?: string;
+  latestTurnRole?: 'user' | 'assistant';
+  isGenerating: boolean;
+}
+
+export interface ComputerChatgptConversationObservationOptions {
+  includeUserHistory?: boolean;
+  includePageText?: boolean;
+}
+
+/**
+ * Opaque exact-conversation attachment. The targetId is durable Computer
+ * identity; provider ids and tab/window handles remain inside the Computer
+ * implementation and can be replaced without changing Supervisor authority.
+ */
+export interface ComputerChatgptConversationTarget {
+  targetId: string;
+  identity: ComputerChatgptTargetIdentity;
+  observe(options?: ComputerChatgptConversationObservationOptions): Promise<ComputerChatgptConversationObservation>;
+  /** UI-only preparation. Must never click Send or create a provider turn. */
+  prepare(prompt: string, options?: { mode?: 'send' | 'resume' | 'recover' }): Promise<{ ready: true } | { ready: false; reasonCode: string }>;
+  dispatch(
+    prompt: string,
+    options?: { mode?: 'send' | 'resume' | 'recover' },
+  ): Promise<
+    | { mutation: 'not_attempted'; reasonCode: string }
+    | { mutation: 'attempted'; confirmed?: boolean }
+  >;
+}
+
+export type ComputerChatgptTargetFailure = {
+  code: string;
+  retryable: boolean;
+  /** Failover is legal only while provider mutation is mechanically impossible. */
+  phase: 'pre_mutation';
+  /** False when provider resource recovery is itself outcome-unknown. */
+  failoverSafe?: boolean;
+  humanAction?: 'login' | 'grant_permission';
+};
+
+export type ComputerChatgptTargetResult =
+  | { state: 'ready'; target: ComputerChatgptConversationTarget; observation?: ComputerChatgptConversationObservation }
+  | { state: 'unavailable'; failure: ComputerChatgptTargetFailure };
+
+export interface ComputerObservedChatgptConversation {
+  conversationId: string;
+  canonicalUrl: string;
+  title?: string;
+  projectTitle?: string;
+  projectUrl?: string;
+  isCurrent?: boolean;
+}
+
+export interface ComputerChatgptConversationInventory {
+  conversations: ComputerObservedChatgptConversation[];
+  /** Full coverage of all supported browser families, not only active providers. */
+  complete: boolean;
+  /** At least one provider completed its own inventory; not exact-target/send proof. */
+  providerInventoryReady?: boolean;
+  unavailableProviders: string[];
+}
+
+/**
+ * Browser/Computer-owned target boundary consumed by Workflow Supervisor.
+ * Implementations own discovery, exact target recovery, provider binding and
+ * transport replacement. They never decide effect admission or effect outcome.
+ */
+export type ComputerChatgptExtensionCommand =
+  | { commandId: string; kind: 'ensure'; identity: ComputerChatgptTargetIdentity; providerBinding?: ComputerSurfaceProviderBinding }
+  | { commandId: string; kind: 'observe'; identity: ComputerChatgptTargetIdentity; providerBinding?: ComputerSurfaceProviderBinding; options?: ComputerChatgptConversationObservationOptions }
+  | { commandId: string; kind: 'dispatch' | 'prepare'; identity: ComputerChatgptTargetIdentity; providerBinding?: ComputerSurfaceProviderBinding; prompt: string; mode?: 'send' | 'resume' | 'recover' }
+  | { commandId: string; kind: 'find_marker'; marker: string; bootstrapKey?: string }
+  | { commandId: string; kind: 'close'; identity: ComputerChatgptTargetIdentity; providerBinding?: ComputerSurfaceProviderBinding };
+export type ComputerChatgptExtensionCommandInput = ComputerChatgptExtensionCommand extends infer Command
+  ? Command extends { commandId: string }
+    ? Omit<Command, 'commandId'>
+    : never
+  : never;
+
+
+export type ComputerChatgptExtensionCommandResult =
+  | { kind: 'ensured'; providerBinding?: ComputerSurfaceProviderBinding; observation?: ComputerChatgptConversationObservation }
+  | { kind: 'observation'; providerBinding?: ComputerSurfaceProviderBinding; observation: ComputerChatgptConversationObservation }
+  | { kind: 'prepared'; ready: true }
+  | { kind: 'prepared'; ready: false; reasonCode: string }
+  | { kind: 'dispatch'; mutation: 'not_attempted'; reasonCode: string }
+  | { kind: 'dispatch'; mutation: 'attempted'; confirmed?: boolean; observation?: ComputerChatgptConversationObservation }
+  | { kind: 'marker_matches'; matches: Array<{ identity: ComputerChatgptConversationIdentity; providerBinding?: ComputerSurfaceProviderBinding; observation: ComputerChatgptConversationObservation }> }
+  | { kind: 'closed' }
+  | { kind: 'failed'; code: string; retryable?: boolean; failoverSafe?: boolean; humanAction?: 'login' | 'grant_permission';
+      /** Exact attachment retained after ensure hydration failed; never Send/readiness authority. */
+      providerBinding?: ComputerSurfaceProviderBinding };
+
+export interface ComputerChatgptExtensionHeartbeat {
+  providerId: string;
+  /** Ephemeral browser/profile provider runtime identity; mechanical binding only. */
+  providerInstanceId: string;
+  observedAt: string;
+  conversations: Array<ComputerObservedChatgptConversation & { providerBinding?: ComputerSurfaceProviderBinding }>;
+}
+
+export interface ComputerChatgptExtensionBrokerRpc {
+  heartbeat(input: ComputerChatgptExtensionHeartbeat): void;
+  claim(providerInstanceId: string): ComputerChatgptExtensionCommand | undefined;
+  complete(providerInstanceId: string, commandId: string, result: ComputerChatgptExtensionCommandResult): boolean;
+}
+
+export interface ComputerChatgptConversationTargetPort {
+  inventory(): Promise<ComputerChatgptConversationInventory>;
+  /** Read-only reconciliation cannot create a missing tab. Only a separately authorized new send may opt in to exact conversation creation. */
+  ensureExact(identity: ComputerChatgptConversationIdentity, options?: { createIfMissing?: boolean }): Promise<ComputerChatgptTargetResult>;
+  openBootstrap(projectUrl: string, bootstrapKey: string): Promise<ComputerChatgptTargetResult>;
+  findBySubmittedMarker(
+    marker: string,
+    bootstrapKey?: string,
+    betweenObservations?: () => Promise<void>,
+  ): Promise<ComputerChatgptTargetResult[]>;
+  promoteBootstrap(targetId: string, identity: ComputerChatgptConversationIdentity): Promise<ComputerChatgptTargetResult>;
+  /** Mechanical cleanup of provider-owned attachments; semantic target identity remains durable. */
+  cleanup(activeResourceKeys: readonly string[]): Promise<void>;
+  release(targetId: string): Promise<void>;
+  close(): Promise<void>;
+}

package/packages/plugin-runtime/computer/index.ts

@@ -4,3 +4,5 @@ export * from './provider-error';
 export * from './provider-registration';
 export * from './target-authority';
 export * from './target-persistence';
+export * from './conversation-target';
+export * from './chatgpt-identity';

package/packages/plugin-runtime/computer/target-authority.ts

@@ -8,8 +8,14 @@ export interface ComputerProviderTargetBinding {
   providerId: string;
   providerSessionId: string;
   observedAt: string;
+  /** Rebuildable exact native process observation for cross-target lifecycle fencing. */
+  processId?: number;
 }
 
+export type ComputerApplicationLaunchProvenance =
+  | { kind: 'preexisting' }
+  | { kind: 'provider_launched'; processId: number };
+
 export type ComputerSurfaceType = 'browser-tab' | 'browser-page';
 export type ComputerSurfaceOwnership = 'plugin_owned' | 'user_owned' | 'provider_owned';
 export type ComputerSurfaceVisibility = 'repositories' | 'controller';
@@ -18,10 +24,19 @@ export type ComputerSurfaceVisibility = 'repositories' | 'controller';
  * Durable semantic description of a Computer surface. Mutable URL/title and
  * provider-specific tab/window handles are deliberately excluded.
  */
+export interface ComputerSurfaceResourceIdentity {
+  /** Stable semantic namespace, for example chatgpt.conversation. */
+  namespace: string;
+  /** Provider-independent durable resource key inside the namespace. */
+  key: string;
+}
+
 export interface ComputerSurfaceStableIdentity {
   surfaceType: ComputerSurfaceType;
   ownership: ComputerSurfaceOwnership;
   application?: ComputerApplicationStableIdentity;
+  /** Durable semantic identity. Provider tab/window/session ids never belong here. */
+  resource?: ComputerSurfaceResourceIdentity;
 }
 
 /**
@@ -52,6 +67,8 @@ export interface ComputerApplicationTarget {
   targetId: string;
   kind: 'application';
   stableIdentity: ComputerApplicationStableIdentity;
+  /** Durable launch fact. Missing means a legacy provider supplied no trustworthy provenance. */
+  launchProvenance?: ComputerApplicationLaunchProvenance;
   providerBinding?: ComputerProviderTargetBinding;
   createdAt: string;
   updatedAt: string;
@@ -93,6 +110,8 @@ export interface ComputerApplicationTargetLease {
 export interface ComputerSurfaceTargetLease {
   current(): ComputerSurfaceTarget;
   bind(binding: ComputerSurfaceProviderBinding): ComputerSurfaceTarget;
+  /** Provider attachment is rebuildable and may be cleared without changing target identity. */
+  clearBinding(): ComputerSurfaceTarget;
   mergeCompatibility(input: { compatibilityAliases?: string[]; repositoryIds?: string[] }): ComputerSurfaceTarget;
   putCompatibility(record: ComputerSurfaceCompatibilityRecord): ComputerSurfaceTarget;
   tombstone(): ComputerSurfaceTarget;
@@ -146,10 +165,15 @@ export interface ComputerInteractionTargetCleanupReport {
 export interface ComputerInteractionTargetAuthorityPort {
   create(
     controllerHome: string,
-    input: { stableIdentity: ComputerApplicationStableIdentity; providerBinding?: ComputerProviderTargetBinding },
+    input: {
+      stableIdentity: ComputerApplicationStableIdentity;
+      launchProvenance?: ComputerApplicationLaunchProvenance;
+      providerBinding?: ComputerProviderTargetBinding;
+    },
   ): ComputerApplicationTarget;
   get(controllerHome: string, targetId: string): ComputerApplicationTarget | undefined;
   require(controllerHome: string, targetId: string): ComputerApplicationTarget;
+  listAllApplications(controllerHome: string): ComputerApplicationTarget[];
   withLease<T>(
     controllerHome: string,
     targetId: string,
@@ -171,6 +195,7 @@ export interface ComputerInteractionTargetAuthorityPort {
   getSurface(controllerHome: string, targetId: string): ComputerSurfaceTarget | undefined;
   requireSurface(controllerHome: string, targetId: string): ComputerSurfaceTarget;
   findSurfaceByAlias(controllerHome: string, alias: string, repoId?: string): ComputerSurfaceTarget | undefined;
+  findSurfaceByStableIdentity(controllerHome: string, identity: ComputerSurfaceStableIdentity, repoId?: string): ComputerSurfaceTarget | undefined;
   findSurfaceByProviderBinding(controllerHome: string, binding: ComputerSurfaceProviderBinding): ComputerSurfaceTarget | undefined;
   listSurfaces(controllerHome: string, options?: { repoId?: string; limit?: number }): ComputerSurfaceTarget[];
   listAllSurfaces(controllerHome: string, options?: { repoId?: string }): ComputerSurfaceTarget[];

package/packages/plugin-runtime/external/unix-jsonl-transport.ts

@@ -5,7 +5,14 @@ const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_HEALTH_TIMEOUT_MS = 2_000;
 const DEFAULT_MAX_REQUEST_BYTES = 1_048_576;
 const DEFAULT_MAX_RESPONSE_BYTES = 1_048_576;
-const MAX_TIMEOUT_MS = 120_000;
+export const MAX_PLUGIN_ACTION_TIMEOUT_MS = 10 * 60_000;
+/**
+ * How long an already-dispatched request keeps its connection open after the
+ * caller stopped waiting. Destroying that socket makes the provider's own write
+ * fail (SIGPIPE / EPIPE) and can terminate a long-running provider service that
+ * is still completing bounded work. Draining absorbs the late response instead.
+ */
+const UNANSWERED_DRAIN_TIMEOUT_MS = 15_000;
 export const EXTERNAL_RPC_METHOD_PATTERN = /^[a-z][a-z0-9_]{0,127}$/;
 
 export type ExternalUnixJsonlMethod = string;
@@ -98,6 +105,61 @@ function transportError(
   return new ExternalUnixJsonlTransportError(code, message, options);
 }
 
+/**
+ * Absorb a response that nobody is waiting for any more.
+ *
+ * A client that abandons a dispatched request must not tear the connection down
+ * underneath the provider: an in-flight provider write to a closed peer raises
+ * SIGPIPE and kills single-threaded provider services, which then restart into
+ * the same request forever. Keeping the connection open until the provider's
+ * own response arrives preserves the provider lifecycle while discarding the
+ * now-meaningless payload.
+ */
+function drainUnansweredResponse(options: {
+  socket: Socket;
+  maxResponseBytes: number;
+  onFinished: (socket: Socket) => void;
+}): void {
+  const { socket, maxResponseBytes, onFinished } = options;
+  if (socket.destroyed) {
+    onFinished(socket);
+    return;
+  }
+  let buffer = Buffer.alloc(0);
+  let settled = false;
+  const settle = (destroy: boolean): void => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    socket.removeListener('data', onData);
+    socket.removeListener('end', onEnd);
+    socket.removeListener('error', onEnd);
+    socket.removeListener('close', onEnd);
+    if (!socket.destroyed) {
+      // The provider finished writing its late response: a graceful half-close
+      // is enough, and it never turns into a provider-side write failure.
+      if (destroy) socket.destroy();
+      else socket.end();
+    }
+    onFinished(socket);
+  };
+  const onData = (chunk: Buffer): void => {
+    if (buffer.length + chunk.length > maxResponseBytes) {
+      settle(true);
+      return;
+    }
+    buffer = Buffer.concat([buffer, chunk]);
+    if (buffer.indexOf(0x0A) >= 0) settle(false);
+  };
+  const onEnd = (): void => settle(true);
+  const timer = setTimeout(() => settle(true), UNANSWERED_DRAIN_TIMEOUT_MS);
+  timer.unref?.();
+  socket.on('data', onData);
+  socket.once('end', onEnd);
+  socket.once('error', onEnd);
+  socket.once('close', onEnd);
+}
+
 function normalizeTransportError(error: unknown): ExternalUnixJsonlTransportError {
   return error instanceof ExternalUnixJsonlTransportError
     ? error
@@ -152,7 +214,7 @@ export function normalizeExternalUnixJsonlCall(
   const params = options.params ?? {};
   const maxRequestBytes = boundedInteger(options.maxRequestBytes, DEFAULT_MAX_REQUEST_BYTES, 1_024, 4 * DEFAULT_MAX_REQUEST_BYTES);
   const maxResponseBytes = boundedInteger(options.maxResponseBytes, DEFAULT_MAX_RESPONSE_BYTES, 1_024, 4 * DEFAULT_MAX_RESPONSE_BYTES);
-  const timeoutMs = boundedInteger(options.timeoutMs, health ? DEFAULT_HEALTH_TIMEOUT_MS : DEFAULT_TIMEOUT_MS, 100, MAX_TIMEOUT_MS);
+  const timeoutMs = boundedInteger(options.timeoutMs, health ? DEFAULT_HEALTH_TIMEOUT_MS : DEFAULT_TIMEOUT_MS, 100, MAX_PLUGIN_ACTION_TIMEOUT_MS);
   const envelope = `${JSON.stringify({ id: options.requestId, method, params })}\n`;
   if (Buffer.byteLength(envelope, 'utf8') > maxRequestBytes) {
     throw transportError('EXTERNAL_PLUGIN_REQUEST_TOO_LARGE', 'External provider request exceeded the bounded input limit.', { retryable: false });
@@ -200,6 +262,9 @@ export class ExternalUnixJsonlChannel {
   private queue: Promise<void> = Promise.resolve();
   private generationValue = 0;
   private disposed = false;
+  private outstandingDispatched = 0;
+  private outstandingMaxResponseBytes = DEFAULT_MAX_RESPONSE_BYTES;
+  private readonly draining = new Set<Socket>();
 
   constructor(readonly socketPath: string) {
     validateSocketPath(socketPath);
@@ -235,6 +300,10 @@ export class ExternalUnixJsonlChannel {
 
   close(): void {
     this.disposed = true;
+    if (this.outstandingDispatched > 0 && this.socket) {
+      this.retireForDrain(this.socket, this.outstandingMaxResponseBytes);
+      return;
+    }
     this.resetSocket();
   }
 
@@ -245,6 +314,24 @@ export class ExternalUnixJsonlChannel {
     this.buffer = Buffer.alloc(0);
   }
 
+  /**
+   * Retire a connection whose request was abandoned by the caller. The socket
+   * leaves service immediately, but stays open until the provider's own
+   * response is absorbed so the provider is never killed by its late write.
+   */
+  private retireForDrain(socket: Socket, maxResponseBytes: number): void {
+    if (this.socket === socket) this.socket = undefined;
+    this.connecting = undefined;
+    this.buffer = Buffer.alloc(0);
+    if (socket.destroyed) return;
+    this.draining.add(socket);
+    drainUnansweredResponse({
+      socket,
+      maxResponseBytes,
+      onFinished: (finished) => { this.draining.delete(finished); },
+    });
+  }
+
   private async ensureConnected(): Promise<void> {
     if (this.connected) return;
     if (this.connecting) return await this.connecting;
@@ -299,7 +386,7 @@ export class ExternalUnixJsonlChannel {
       let settled = false;
       let dispatched = false;
       let socket: Socket | undefined;
-      const finish = (callback: () => void, reset = false): void => {
+      const finish = (callback: () => void, disposition: 'keep' | 'reset' | 'drain' = 'keep'): void => {
         if (settled) return;
         settled = true;
         if (timer) clearTimeout(timer);
@@ -307,15 +394,20 @@ export class ExternalUnixJsonlChannel {
         socket?.removeListener('data', onData);
         socket?.removeListener('error', onError);
         socket?.removeListener('end', onEnd);
-        if (reset) this.resetSocket(socket);
+        if (dispatched) this.outstandingDispatched = Math.max(0, this.outstandingDispatched - 1);
+        if (disposition === 'reset') this.resetSocket(socket);
+        else if (disposition === 'drain' && socket) this.retireForDrain(socket, normalized.maxResponseBytes);
         callback();
       };
-      const fail = (error: unknown, reset = true): void => {
+      const fail = (error: unknown, disposition: 'keep' | 'reset' | 'drain' = 'reset'): void => {
         const normalizedError = normalizeTransportError(error);
         const classified = dispatched && mayHaveEffects ? markOutcomeUnknown(normalizedError) : normalizedError;
-        finish(() => reject(classified), reset);
+        finish(() => reject(classified), disposition);
       };
-      const onAbort = (): void => fail(transportError('EXTERNAL_PLUGIN_ABORTED', 'External provider request was cancelled.'));
+      const onAbort = (): void => fail(
+        transportError('EXTERNAL_PLUGIN_ABORTED', 'External provider request was cancelled.'),
+        dispatched ? 'drain' : 'reset',
+      );
       const onError = (error: Error): void => fail(transportError('EXTERNAL_PLUGIN_SOCKET_UNAVAILABLE', error.message));
       const onEnd = (): void => fail(transportError('EXTERNAL_PLUGIN_PROTOCOL_ERROR', 'External provider closed the socket before returning a complete response.'));
       const onData = (chunk: Buffer): void => {
@@ -338,14 +430,22 @@ export class ExternalUnixJsonlChannel {
           finish(() => resolve(decoded));
         } catch (error) {
           if (error instanceof ExternalUnixJsonlTransportError && error.source === 'provider') {
-            fail(error, false);
+            fail(error, 'keep');
           } else {
             fail(error);
           }
         }
       };
 
-      timer = setTimeout(() => fail(transportError('EXTERNAL_PLUGIN_TIMEOUT', `External provider request timed out after ${normalized.timeoutMs}ms.`)), normalized.timeoutMs);
+      // A request the caller stopped waiting for is not a reason to kill the
+      // provider: retire the connection into a bounded drain instead.
+      timer = setTimeout(
+        () => fail(
+          transportError('EXTERNAL_PLUGIN_TIMEOUT', `External provider request timed out after ${normalized.timeoutMs}ms.`),
+          dispatched ? 'drain' : 'reset',
+        ),
+        normalized.timeoutMs,
+      );
       timer.unref?.();
       options.signal?.addEventListener('abort', onAbort, { once: true });
 
@@ -361,7 +461,7 @@ export class ExternalUnixJsonlChannel {
           'EXTERNAL_PLUGIN_CHANNEL_GENERATION_CHANGED',
           `External provider connection changed from generation ${expectedGeneration} to ${this.generation}; renegotiate before executing the action.`,
           { retryable: true },
-        ), false);
+        ), 'keep');
         return;
       }
       socket = this.socket;
@@ -373,6 +473,8 @@ export class ExternalUnixJsonlChannel {
       socket.once('error', onError);
       socket.once('end', onEnd);
       dispatched = true;
+      this.outstandingDispatched += 1;
+      this.outstandingMaxResponseBytes = normalized.maxResponseBytes;
       socket.write(normalized.envelope, (error) => {
         if (error) fail(transportError('EXTERNAL_PLUGIN_TRANSPORT_FAILED', error.message));
       });
@@ -399,21 +501,32 @@ export async function callExternalUnixJsonl(
     let dispatched = false;
     let buffer = Buffer.alloc(0);
 
-    const cleanup = (): void => {
+    const cleanup = (disposition: 'destroy' | 'drain'): void => {
       if (timer) clearTimeout(timer);
       options.signal?.removeEventListener('abort', onAbort);
-      if (socket && !socket.destroyed) socket.destroy();
+      if (!socket || socket.destroyed) return;
+      if (disposition === 'drain') {
+        // The socket is dead to this one-shot caller, so only the drain reader
+        // may keep observing it.
+        socket.removeAllListeners('data');
+        socket.removeAllListeners('error');
+        socket.removeAllListeners('end');
+        socket.removeAllListeners('close');
+        drainUnansweredResponse({ socket, maxResponseBytes: normalized.maxResponseBytes, onFinished: () => undefined });
+        return;
+      }
+      socket.destroy();
     };
-    const finish = (callback: () => void): void => {
+    const finish = (callback: () => void, disposition: 'destroy' | 'drain' = 'destroy'): void => {
       if (settled) return;
       settled = true;
-      cleanup();
+      cleanup(disposition);
       callback();
     };
-    const fail = (error: unknown): void => {
+    const fail = (error: unknown, disposition: 'destroy' | 'drain' = 'destroy'): void => {
       const normalizedError = normalizeTransportError(error);
       const classified = dispatched && mayHaveEffects ? markOutcomeUnknown(normalizedError) : normalizedError;
-      finish(() => reject(classified));
+      finish(() => reject(classified), disposition);
     };
     const succeed = (raw: string): void => finish(() => {
       try {
@@ -422,9 +535,20 @@ export async function callExternalUnixJsonl(
         reject(error);
       }
     });
-    const onAbort = (): void => fail(transportError('EXTERNAL_PLUGIN_ABORTED', 'External provider request was cancelled.'));
+    const onAbort = (): void => fail(
+      transportError('EXTERNAL_PLUGIN_ABORTED', 'External provider request was cancelled.'),
+      dispatched ? 'drain' : 'destroy',
+    );
 
-    timer = setTimeout(() => fail(transportError('EXTERNAL_PLUGIN_TIMEOUT', `External provider request timed out after ${normalized.timeoutMs}ms.`)), normalized.timeoutMs);
+    // Preserve the provider lifecycle: an abandoned request is drained instead
+    // of being answered with a closed connection.
+    timer = setTimeout(
+      () => fail(
+        transportError('EXTERNAL_PLUGIN_TIMEOUT', `External provider request timed out after ${normalized.timeoutMs}ms.`),
+        dispatched ? 'drain' : 'destroy',
+      ),
+      normalized.timeoutMs,
+    );
     timer.unref?.();
     options.signal?.addEventListener('abort', onAbort, { once: true });