@love-moon/conductor-cli 0.2.38 → 0.2.40

package/bin/conductor-fire.js

@@ -29,7 +29,9 @@ import {
 import {
   filterRuntimeSupportedAllowCliList,
   isBuiltInRuntimeBackend,
+  isCommandOptionalBuiltInRuntimeBackend,
   listAdvertisedBackends,
+  parseCommandParts,
   resolveConfiguredRuntimeBackend,
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
@@ -69,9 +71,20 @@ const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1
   "",
 );
 
-export function buildConductorConnectHeaders(version = pkgJson.version) {
+export function buildConductorConnectHeaders(
+  version = pkgJson.version,
+  options = {},
+) {
+  const backends = Array.isArray(options.backends)
+    ? options.backends.map((entry) => String(entry || "").trim()).filter(Boolean)
+    : [];
+  const capabilities = Array.isArray(options.capabilities)
+    ? options.capabilities.map((entry) => String(entry || "").trim()).filter(Boolean)
+    : [];
   return {
     "x-conductor-version": version,
+    ...(backends.length > 0 ? { "x-conductor-backends": backends.join(",") } : {}),
+    ...(capabilities.length > 0 ? { "x-conductor-capabilities": capabilities.join(",") } : {}),
   };
 }
 
@@ -89,6 +102,13 @@ export function shouldRunReconnectRecovery({
   return !runner.shouldSuppressReconnectRecovery();
 }
 
+export function shouldFireReportTaskStatus({ launchedByDaemon = false, phase } = {}) {
+  if (phase === "final") {
+    return true;
+  }
+  return !launchedByDaemon;
+}
+
 // Load allow_cli_list from config file (no defaults - must be configured)
 function loadFireConfigYaml(configFilePath) {
   const home = os.homedir();
@@ -148,70 +168,8 @@ export function resolveConfiguredPrePrompt({ configFilePath, backend, sessionBac
   return undefined;
 }
 
-function parseCommandParts(commandLine) {
-  const input = String(commandLine || "").trim();
-  if (!input) {
-    return [];
-  }
-
-  const parts = [];
-  let current = "";
-  let quote = "";
-  let escaping = false;
-  let tokenStarted = false;
-
-  for (const char of input) {
-    if (escaping) {
-      current += char;
-      tokenStarted = true;
-      escaping = false;
-      continue;
-    }
-
-    if (char === "\\") {
-      escaping = true;
-      tokenStarted = true;
-      continue;
-    }
-
-    if (quote) {
-      if (char === quote) {
-        quote = "";
-      } else {
-        current += char;
-      }
-      tokenStarted = true;
-      continue;
-    }
-
-    if (char === "'" || char === "\"") {
-      quote = char;
-      tokenStarted = true;
-      continue;
-    }
-
-    if (/\s/.test(char)) {
-      if (tokenStarted) {
-        parts.push(current);
-        current = "";
-        tokenStarted = false;
-      }
-      continue;
-    }
-
-    current += char;
-    tokenStarted = true;
-  }
-
-  if (tokenStarted) {
-    parts.push(current);
-  }
-
-  return parts;
-}
-
 function extractModelOptionFromCommandLine(commandLine) {
-  const parts = parseCommandParts(commandLine);
+  const { parts } = parseCommandParts(commandLine);
   for (let index = 0; index < parts.length; index += 1) {
     const token = String(parts[index] || "").trim();
     if (!token) {
@@ -577,6 +535,39 @@ export class FireWatchdog {
   }
 }
 
+export function createPendingRemoteInterruptQueue() {
+  const pending = [];
+
+  return {
+    enqueue(event) {
+      return new Promise((resolve) => {
+        pending.push({ event, resolve });
+      });
+    },
+
+    async flushWith(dispatch) {
+      while (pending.length > 0) {
+        const next = pending.shift();
+        if (!next) {
+          continue;
+        }
+        try {
+          next.resolve(await dispatch(next.event));
+        } catch {
+          next.resolve(false);
+        }
+      }
+    },
+
+    rejectAll() {
+      while (pending.length > 0) {
+        const next = pending.shift();
+        next?.resolve(false);
+      }
+    },
+  };
+}
+
 async function main() {
   syncPwdEnvWithProcessCwdForDaemonLaunch();
   const cliArgs = await parseCliArgs();
@@ -624,7 +615,8 @@ async function main() {
   let resumeContext = null;
   if (cliArgs.resumeSessionId) {
     const bootstrap = await bootstrapResumeContextForFire({
-      backend: cliArgs.sessionBackend || cliArgs.backend,
+      backend: cliArgs.backend,
+      sessionBackend: cliArgs.sessionBackend,
       configFile: cliArgs.configFile,
       resumeSessionId: cliArgs.resumeSessionId,
     });
@@ -637,6 +629,8 @@ async function main() {
   let reconnectRunner = null;
   let reconnectTaskId = null;
   let pendingRemoteStopEvent = null;
+  const pendingRemoteInterruptQueue = createPendingRemoteInterruptQueue();
+  const completedRefreshSessionRequests = new Map();
   let conductor = null;
   let reconnectResumeInFlight = false;
   let fireShuttingDown = false;
@@ -676,7 +670,7 @@ async function main() {
           source: "conductor-fire",
           metadata: { reconnect: true },
         });
-        if (!launchedByDaemon) {
+        if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "reconnect_running" })) {
           await conductor.sendTaskStatus(reconnectTaskId, {
             status: "RUNNING",
             summary: "conductor fire reconnected",
@@ -706,6 +700,56 @@ async function main() {
     pendingRemoteStopEvent = event;
   };
 
+  const handleInterruptTurnCommand = async (event) => {
+    fireWatchdog.onInbound();
+    if (!event || typeof event !== "object") {
+      return false;
+    }
+    const taskId = typeof event.taskId === "string" ? event.taskId : "";
+    if (reconnectTaskId && taskId && taskId !== reconnectTaskId) {
+      return false;
+    }
+    if (reconnectRunner && typeof reconnectRunner.requestInterruptFromRemote === "function") {
+      return await reconnectRunner.requestInterruptFromRemote(event);
+    }
+    return await pendingRemoteInterruptQueue.enqueue(event);
+  };
+
+  const rememberCompletedRefreshSessionRequest = (requestId, accepted) => {
+    if (!requestId) {
+      return accepted;
+    }
+    completedRefreshSessionRequests.set(requestId, accepted);
+    while (completedRefreshSessionRequests.size > 20) {
+      const oldest = completedRefreshSessionRequests.keys().next();
+      if (oldest.done) {
+        break;
+      }
+      completedRefreshSessionRequests.delete(oldest.value);
+    }
+    return accepted;
+  };
+
+  const handleRefreshSessionCommand = async (event) => {
+    fireWatchdog.onInbound();
+    if (!event || typeof event !== "object") {
+      return false;
+    }
+    const taskId = typeof event.taskId === "string" ? event.taskId : "";
+    const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
+    if (reconnectTaskId && taskId && taskId !== reconnectTaskId) {
+      return false;
+    }
+    if (requestId && completedRefreshSessionRequests.has(requestId)) {
+      return completedRefreshSessionRequests.get(requestId) === true;
+    }
+    if (reconnectRunner && typeof reconnectRunner.requestRefreshSessionFromRemote === "function") {
+      const accepted = await reconnectRunner.requestRefreshSessionFromRemote(event);
+      return rememberCompletedRefreshSessionRequest(requestId, accepted !== false);
+    }
+    return rememberCompletedRefreshSessionRequest(requestId, false);
+  };
+
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
@@ -740,7 +784,10 @@ async function main() {
     conductor = await ConductorClient.connect({
       projectPath: runtimeProjectPath,
       extraEnv: env,
-      extraHeaders: buildConductorConnectHeaders(),
+      extraHeaders: buildConductorConnectHeaders(pkgJson.version, {
+        backends: [cliArgs.backend],
+        capabilities: ["refresh_session_inplace"],
+      }),
       configFile: cliArgs.configFile,
       onConnected: (event) => {
         fireWatchdog.onConnected(event);
@@ -756,6 +803,8 @@ async function main() {
         fireWatchdog.onPong(event);
       },
       onStopTask: handleStopTaskCommand,
+      onInterruptTurn: handleInterruptTurnCommand,
+      onRefreshSession: handleRefreshSessionCommand,
     });
 
     const taskContext = await ensureTaskContext(conductor, {
@@ -795,7 +844,10 @@ async function main() {
       }
     }
 
-    const resolvedResumeSessionId = cliArgs.resumeSessionId;
+    let nextResumeSessionId = cliArgs.resumeSessionId;
+    let nextInitialPrompt =
+      taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "";
+    let pendingRefreshSessionRequest = null;
 
     const sessionCommandLine = resolveAiSessionCommandLine(
       cliArgs.backend,
@@ -810,19 +862,6 @@ async function main() {
       env: process.env,
     });
 
-    backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
-      initialImages: cliArgs.initialImages,
-      cwd: runtimeProjectPath,
-      resumeSessionId: resolvedResumeSessionId,
-      configFile: cliArgs.configFile,
-      ...(cliArgs.sessionOptions || {}),
-      ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
-      logger: { log },
-      ...(resolvedPrePrompt ? { prePrompt: resolvedPrePrompt } : {}),
-      sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
-      resumePersistedSession: Boolean(!resolvedResumeSessionId && taskContext.taskId),
-    });
-
     log(`Using backend: ${cliArgs.backend}`);
 
     try {
@@ -835,25 +874,6 @@ async function main() {
       log(`Failed to report agent resume: ${error?.message || error}`);
     }
 
-    const runner = new BridgeRunner({
-      backendSession,
-      conductor,
-      taskId: taskContext.taskId,
-      pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
-      initialPrompt: taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "",
-      initialPromptDelivery: taskContext.initialPromptDelivery || "none",
-      includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
-      cliArgs: cliArgs.rawBackendArgs,
-      backendName: cliArgs.backend,
-      resumeSessionId: resolvedResumeSessionId,
-      daemonName: resolvedDaemonName,
-    });
-    reconnectRunner = runner;
-    if (pendingRemoteStopEvent) {
-      await runner.requestStopFromRemote(pendingRemoteStopEvent);
-      pendingRemoteStopEvent = null;
-    }
-
     const signals = new AbortController();
     let shutdownSignal = null;
     let backendShutdownRequested = false;
@@ -887,7 +907,7 @@ async function main() {
     process.on("SIGINT", onSigint);
     process.on("SIGTERM", onSigterm);
 
-    if (!launchedByDaemon) {
+    if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "running" })) {
       try {
         await conductor.sendTaskStatus(taskContext.taskId, {
           status: "RUNNING",
@@ -897,68 +917,148 @@ async function main() {
       }
     }
 
-    let runnerError = null;
     try {
-      if (!resolvedResumeSessionId && String(cliArgs.sessionBackend || cliArgs.backend).trim().toLowerCase() === "codex") {
-        await withFreshSessionBootstrapLock(cliArgs.sessionBackend || cliArgs.backend, runtimeProjectPath, async () => {
-          await runner.announceBackendSession();
+      while (true) {
+        const currentRefreshSessionRequest = pendingRefreshSessionRequest;
+        let runnerError = null;
+
+        backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
+          initialImages: cliArgs.initialImages,
+          cwd: runtimeProjectPath,
+          resumeSessionId: nextResumeSessionId,
+          configFile: cliArgs.configFile,
+          ...(cliArgs.sessionOptions || {}),
+          ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
+          logger: { log },
+          ...(resolvedPrePrompt ? { prePrompt: resolvedPrePrompt } : {}),
+          sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
+          resumePersistedSession: Boolean(!nextResumeSessionId && taskContext.taskId),
         });
-      }
-      await runner.start(signals.signal);
-    } catch (error) {
-      runnerError = error;
-      throw error;
-    } finally {
-      process.off("SIGINT", onSigint);
-      process.off("SIGTERM", onSigterm);
-      if (!launchedByDaemon) {
-        const remoteStopReason = typeof runner.getRemoteStopReason === "function" ? runner.getRemoteStopReason() : null;
-        const remoteStopSummary = typeof runner.getRemoteStopSummary === "function" ? runner.getRemoteStopSummary() : null;
-        // When the task was deleted by the user, the DB record is already gone —
-        // attempting to send a final status update would fail with 500 and the
-        // SDK durable outbox would retry forever, preventing the process from
-        // exiting.
-        const taskDeletedByUser = remoteStopReason === "deleted_by_user";
-        const finalStatus = shutdownSignal
-          ? {
-              status: "KILLED",
-              summary: `terminated by ${shutdownSignal}`,
-            }
-          : runnerError
+
+        const runner = new BridgeRunner({
+          backendSession,
+          conductor,
+          taskId: taskContext.taskId,
+          pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
+          initialPrompt: nextInitialPrompt,
+          initialPromptDelivery: taskContext.initialPromptDelivery || "none",
+          includeInitialImages: Boolean(nextInitialPrompt && cliArgs.initialImages.length),
+          cliArgs: cliArgs.rawBackendArgs,
+          backendName: cliArgs.backend,
+          resumeSessionId: nextResumeSessionId,
+          daemonName: resolvedDaemonName,
+        });
+        reconnectRunner = runner;
+        if (pendingRemoteStopEvent) {
+          await runner.requestStopFromRemote(pendingRemoteStopEvent);
+          pendingRemoteStopEvent = null;
+        }
+        await pendingRemoteInterruptQueue.flushWith((event) => runner.requestInterruptFromRemote(event));
+
+        try {
+          if (currentRefreshSessionRequest) {
+            await runner.announceBackendSession();
+            currentRefreshSessionRequest.resolve(true);
+            pendingRefreshSessionRequest = null;
+          } else if (
+            !nextResumeSessionId &&
+            String(cliArgs.sessionBackend || cliArgs.backend).trim().toLowerCase() === "codex"
+          ) {
+            await withFreshSessionBootstrapLock(
+              cliArgs.sessionBackend || cliArgs.backend,
+              runtimeProjectPath,
+              async () => {
+                await runner.announceBackendSession();
+              },
+            );
+          }
+          await runner.start(signals.signal);
+        } catch (error) {
+          runnerError = error;
+          if (currentRefreshSessionRequest) {
+            currentRefreshSessionRequest.resolve(false);
+            pendingRefreshSessionRequest = null;
+          }
+        }
+
+        const refreshSessionRequest =
+          typeof runner.getRefreshSessionRequest === "function"
+            ? runner.getRefreshSessionRequest()
+            : null;
+        if (!runnerError && !shutdownSignal && refreshSessionRequest) {
+          const refreshedSessionId =
+            refreshSessionRequest.sessionId ||
+            (typeof runner.boundSessionId === "string" ? runner.boundSessionId.trim() : "") ||
+            nextResumeSessionId;
+          if (refreshedSessionId) {
+            nextResumeSessionId = refreshedSessionId;
+            nextInitialPrompt = "";
+            pendingRefreshSessionRequest = refreshSessionRequest;
+            continue;
+          }
+          runnerError = new Error("refresh_session requires a bound session id");
+        }
+        if (refreshSessionRequest && refreshSessionRequest !== pendingRefreshSessionRequest) {
+          refreshSessionRequest.resolve(false);
+        }
+
+        if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "final" })) {
+          const remoteStopReason = typeof runner.getRemoteStopReason === "function" ? runner.getRemoteStopReason() : null;
+          const remoteStopSummary = typeof runner.getRemoteStopSummary === "function" ? runner.getRemoteStopSummary() : null;
+          // When the task was deleted by the user, the DB record is already gone —
+          // attempting to send a final status update would fail with 500 and the
+          // SDK durable outbox would retry forever, preventing the process from
+          // exiting.
+          const taskDeletedByUser = remoteStopReason === "deleted_by_user";
+          const finalStatus = shutdownSignal
             ? {
                 status: "KILLED",
-                summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
+                summary: `terminated by ${shutdownSignal}`,
               }
-            : remoteStopSummary
+            : runnerError
               ? {
                   status: "KILLED",
-                  summary: remoteStopSummary,
+                  summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
                 }
-            : {
-                status: "COMPLETED",
-                summary: "conductor fire exited",
-              };
-        if (!taskDeletedByUser) {
-          try {
-            const statusResult = await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
-            if (statusResult?.pending && typeof conductor.flushPendingUpstreamEvents === "function") {
-              await conductor.flushPendingUpstreamEvents({
-                timeoutMs: 5_000,
-                retryIntervalMs: 250,
-              });
+              : remoteStopSummary
+                ? {
+                    status: "KILLED",
+                    summary: remoteStopSummary,
+                  }
+                : {
+                    status: "COMPLETED",
+                    summary: "conductor fire exited",
+                  };
+          if (!taskDeletedByUser) {
+            try {
+              const statusResult = await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
+              if (statusResult?.pending && typeof conductor.flushPendingUpstreamEvents === "function") {
+                await conductor.flushPendingUpstreamEvents({
+                  timeoutMs: 5_000,
+                  retryIntervalMs: 250,
+                });
+              }
+            } catch (error) {
+              log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
+            }
+          } else {
+            log(`Skipping final status report: task was deleted by user`);
+            // Also clear any pending durable outbox retries (e.g. task_stop_ack)
+            // that would keep failing against the deleted task.
+            if (typeof conductor.clearDurableOutboxTimer === "function") {
+              conductor.clearDurableOutboxTimer();
             }
-          } catch (error) {
-            log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
-          }
-        } else {
-          log(`Skipping final status report: task was deleted by user`);
-          // Also clear any pending durable outbox retries (e.g. task_stop_ack)
-          // that would keep failing against the deleted task.
-          if (typeof conductor.clearDurableOutboxTimer === "function") {
-            conductor.clearDurableOutboxTimer();
           }
         }
+
+        if (runnerError) {
+          throw runnerError;
+        }
+        break;
       }
+    } finally {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
       if (shutdownSignal === "SIGINT") {
         process.exitCode = 130;
       } else if (shutdownSignal === "SIGTERM") {
@@ -966,6 +1066,7 @@ async function main() {
       }
     }
   } finally {
+    pendingRemoteInterruptQueue.rejectAll();
     fireShuttingDown = true;
     fireWatchdog.stop();
     if (backendSession && typeof backendSession.close === "function") {
@@ -1183,6 +1284,12 @@ Environment:
   const requestedBackend = conductorArgs.backend
     ? normalizeRuntimeBackendName(conductorArgs.backend)
     : supportedBackends[0] || externalBackends[0];
+  if ((conductorArgs.listBackends || listBackendsWithoutSeparator) && discoveryError) {
+    throw discoveryError;
+  }
+  if (!conductorArgs.backend && discoveryError && isCommandOptionalBuiltInRuntimeBackend(requestedBackend)) {
+    throw discoveryError;
+  }
   const configuredBackend = await resolveConfiguredRuntimeBackend(requestedBackend, allowCliList, {
     configFilePath: configFileFromArgs,
   });
@@ -1207,7 +1314,9 @@ Environment:
   const isAllowedExternalBackend =
     !isBuiltInRuntimeBackend(sessionBackend) &&
     advertisedExternalBackends.has(sessionBackend);
-  if (backend && shouldRequireBackend && !hasConfiguredEntry && !isAllowedExternalBackend) {
+  const isCommandOptionalBuiltInBackend =
+    isCommandOptionalBuiltInRuntimeBackend(sessionBackend || backend);
+  if (backend && shouldRequireBackend && !hasConfiguredEntry && !isAllowedExternalBackend && !isCommandOptionalBuiltInBackend) {
     throw new Error(
       `Unsupported backend "${backend}". Supported backends: ${[...runtimeSupportedBackends].join(", ") || "none configured"}.`,
     );
@@ -1559,6 +1668,7 @@ export async function resolveResumeContext(backend, sessionId, options = {}) {
 
 export async function bootstrapResumeContextForFire({
   backend,
+  sessionBackend,
   configFile,
   resumeSessionId,
   env = process.env,
@@ -1582,7 +1692,8 @@ export async function bootstrapResumeContextForFire({
     return { resumeContext, runtimeProjectPath };
   }
 
-  resumeContext = await resolveResumeContextFn(backend, resumeSessionId, {
+  const resumeLookupBackend = backend || sessionBackend;
+  resumeContext = await resolveResumeContextFn(resumeLookupBackend, resumeSessionId, {
     configFilePath: configFile,
   });
   const sessionLocation = resumeContext.sessionPath ? ` at ${resumeContext.sessionPath}` : "";
@@ -1731,6 +1842,10 @@ export class BridgeRunner {
       os.hostname();
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
+    this.refreshSessionRequest = null;
+    this.remoteInterruptsByReplyTo = new Map();
+    this.pendingInterruptRetryTimers = new Map();
+    this.activeTurnReplyTo = "";
     this.sessionAnnouncementSent = false;
     this.boundSessionId = "";
     this.errorLoop = null;
@@ -1947,7 +2062,11 @@ export class BridgeRunner {
   }
 
   shouldSuppressReconnectRecovery() {
-    return this.stopped || Boolean(this.remoteStopInfo);
+    return this.stopped || Boolean(this.remoteStopInfo) || Boolean(this.refreshSessionRequest);
+  }
+
+  getRefreshSessionRequest() {
+    return this.refreshSessionRequest;
   }
 
   getRemoteStopReason() {
@@ -1990,6 +2109,248 @@ export class BridgeRunner {
     }
   }
 
+  async requestRefreshSessionFromRemote(event = {}) {
+    const taskId = typeof event.taskId === "string" ? event.taskId.trim() : "";
+    if (taskId && taskId !== this.taskId) {
+      return false;
+    }
+    const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
+    const sessionId = typeof event.sessionId === "string" ? event.sessionId.trim() : "";
+    const sessionFilePath =
+      typeof event.sessionFilePath === "string" && event.sessionFilePath.trim()
+        ? event.sessionFilePath.trim()
+        : "";
+    if (!sessionId) {
+      return false;
+    }
+    if (this.refreshSessionRequest) {
+      if (
+        requestId &&
+        this.refreshSessionRequest.requestId &&
+        this.refreshSessionRequest.requestId === requestId
+      ) {
+        return await this.refreshSessionRequest.promise;
+      }
+      return false;
+    }
+
+    let resolveRefresh;
+    const promise = new Promise((resolve) => {
+      resolveRefresh = resolve;
+    });
+    this.refreshSessionRequest = {
+      requestId: requestId || null,
+      sessionId,
+      sessionFilePath: sessionFilePath || null,
+      promise,
+      resolve: resolveRefresh,
+    };
+    log(`Received refresh_session for ${this.taskId}; rebuilding backend session in-process`);
+    this.stopped = true;
+    if (typeof this.backendSession?.close === "function") {
+      try {
+        await this.backendSession.close();
+      } catch (error) {
+        log(`Failed to close backend session for refresh ${this.taskId}: ${error?.message || error}`);
+      }
+    }
+    return await promise;
+  }
+
+  normalizeReplyTarget(replyTo) {
+    return typeof replyTo === "string" ? replyTo.trim() : "";
+  }
+
+  isTurnInterruptedError(error) {
+    const reason = typeof error?.reason === "string" ? error.reason.trim().toLowerCase() : "";
+    if (reason === "turn_interrupted" || reason === "turn_cancelled") {
+      return true;
+    }
+    const turnStatus = typeof error?.turnStatus === "string" ? error.turnStatus.trim().toLowerCase() : "";
+    if (
+      turnStatus === "interrupted" ||
+      turnStatus === "cancelled" ||
+      turnStatus === "canceled" ||
+      turnStatus === "aborted"
+    ) {
+      return true;
+    }
+    const name = typeof error?.name === "string" ? error.name.trim().toLowerCase() : "";
+    if (name === "aborterror") {
+      return true;
+    }
+    const message = String(error?.message || error || "").toLowerCase();
+    return (
+      message.includes(" interrupted") ||
+      message.includes("interrupt ") ||
+      message.includes("turn interrupted") ||
+      message.includes("cancelled") ||
+      message.includes("canceled") ||
+      message.includes("aborted")
+    );
+  }
+
+  async requestInterruptFromRemote(event = {}) {
+    const taskId = typeof event.taskId === "string" ? event.taskId.trim() : "";
+    if (taskId && taskId !== this.taskId) {
+      return false;
+    }
+    const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
+    const reason = typeof event.reason === "string" ? event.reason.trim() : "";
+    const targetReplyTo = this.normalizeReplyTarget(event.targetReplyTo);
+    if (!targetReplyTo) {
+      return false;
+    }
+    if (this.processedMessageIds.has(targetReplyTo)) {
+      this.copilotLog(`ignore late interrupt_turn for processed replyTo=${targetReplyTo}`);
+      return false;
+    }
+
+    const existing = this.remoteInterruptsByReplyTo.get(targetReplyTo) || {};
+    const interruptInfo = {
+      requestId: requestId || existing.requestId || null,
+      reason: reason || existing.reason || "user_interrupt",
+      issued: Boolean(existing.issued),
+    };
+    this.remoteInterruptsByReplyTo.set(targetReplyTo, interruptInfo);
+    log(
+      `Received interrupt_turn for ${this.taskId} replyTo=${targetReplyTo}${
+        interruptInfo.reason ? ` (${interruptInfo.reason})` : ""
+      }`,
+    );
+    return await this.issueInterruptForReplyTarget(targetReplyTo);
+  }
+
+  async issueInterruptForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    if (!normalizedReplyTo) {
+      return false;
+    }
+    const interruptInfo = this.remoteInterruptsByReplyTo.get(normalizedReplyTo);
+    if (!interruptInfo) {
+      return false;
+    }
+    if (interruptInfo.issued) {
+      return true;
+    }
+    const supportsTurnInterrupt = typeof this.backendSession?.interruptCurrentTurn === "function";
+    const isActiveTarget = this.runningTurn && normalizedReplyTo === this.activeTurnReplyTo;
+    const isInFlightTarget = this.inFlightMessageIds.has(normalizedReplyTo);
+
+    if (!isActiveTarget && isInFlightTarget) {
+      this.copilotLog(`interrupt arrived after replyTo=${normalizedReplyTo} stopped being interruptible`);
+      return false;
+    }
+
+    if (!isActiveTarget) {
+      if (!supportsTurnInterrupt) {
+        log(`Backend session for ${this.taskId} does not support turn interruption`);
+        return false;
+      }
+      this.copilotLog(`queued interrupt request for future replyTo=${normalizedReplyTo}`);
+      return true;
+    }
+
+    if (!supportsTurnInterrupt) {
+      log(`Backend session for ${this.taskId} does not support turn interruption`);
+      return false;
+    }
+    try {
+      const interrupted = await this.backendSession.interruptCurrentTurn();
+      if (interrupted === false) {
+        interruptInfo.issued = false;
+        this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+        if (
+          this.runningTurn &&
+          this.activeTurnReplyTo === normalizedReplyTo &&
+          this.inFlightMessageIds.has(normalizedReplyTo)
+        ) {
+          this.copilotLog(`backend interrupt not ready replyTo=${normalizedReplyTo}; retrying`);
+          this.scheduleInterruptRetryForReplyTarget(normalizedReplyTo);
+          return true;
+        }
+        return false;
+      }
+      interruptInfo.issued = true;
+      this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+      this.copilotLog(`requested backend interrupt replyTo=${normalizedReplyTo}`);
+      return true;
+    } catch (error) {
+      interruptInfo.issued = false;
+      this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+      log(`Failed to interrupt replyTo=${normalizedReplyTo} for ${this.taskId}: ${error?.message || error}`);
+      return false;
+    }
+  }
+
+  scheduleInterruptRetryForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    if (!normalizedReplyTo || this.pendingInterruptRetryTimers.has(normalizedReplyTo)) {
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      this.pendingInterruptRetryTimers.delete(normalizedReplyTo);
+      const interruptInfo = this.remoteInterruptsByReplyTo.get(normalizedReplyTo);
+      if (
+        !interruptInfo ||
+        interruptInfo.issued ||
+        this.processedMessageIds.has(normalizedReplyTo) ||
+        !this.runningTurn ||
+        this.activeTurnReplyTo !== normalizedReplyTo ||
+        !this.inFlightMessageIds.has(normalizedReplyTo)
+      ) {
+        return;
+      }
+      void this.issueInterruptForReplyTarget(normalizedReplyTo);
+    }, 50);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    this.pendingInterruptRetryTimers.set(normalizedReplyTo, timer);
+  }
+
+  clearInterruptRetryForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    const timer = this.pendingInterruptRetryTimers.get(normalizedReplyTo);
+    if (!timer) {
+      return;
+    }
+    clearTimeout(timer);
+    this.pendingInterruptRetryTimers.delete(normalizedReplyTo);
+  }
+
+  async handleInterruptedTurn(replyTo, interruptInfo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    this.clearInterruptRetryForReplyTarget(normalizedReplyTo);
+    this.copilotLog(`turn interrupted replyTo=${normalizedReplyTo || "latest"}`);
+    await this.reportRuntimeStatus(
+      {
+        phase: "interrupted",
+        reply_in_progress: false,
+        status_done_line: "Conversation interrupted",
+      },
+      normalizedReplyTo,
+    );
+    try {
+      await this.conductor.sendMessage(this.taskId, "Conversation interrupted", {
+        backend: this.backendName,
+        reply_to: normalizedReplyTo || undefined,
+        interrupted: true,
+        interruption_request_id: interruptInfo?.requestId || undefined,
+        reason: interruptInfo?.reason || undefined,
+        cli_args: this.cliArgs,
+      });
+    } catch (error) {
+      log(`Failed to send interrupt confirmation for ${this.taskId}: ${error?.message || error}`);
+    }
+    if (normalizedReplyTo) {
+      this.processedMessageIds.add(normalizedReplyTo);
+      this.remoteInterruptsByReplyTo.delete(normalizedReplyTo);
+    }
+    this.resetErrorLoop();
+  }
+
   async recoverAfterReconnect() {
     if (!this.needsReconnectRecovery) {
       return;
@@ -2502,6 +2863,7 @@ export class BridgeRunner {
     }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    this.activeTurnReplyTo = this.normalizeReplyTarget(replyTo);
     const turnStartedAt = Date.now();
     let turnWatchdog = null;
     if (this.isCopilotBackend) {
@@ -2540,12 +2902,15 @@ export class BridgeRunner {
         );
       }
 
-      const result = await this.backendSession.runTurn(content, {
+      const turnPromise = this.backendSession.runTurn(content, {
         useInitialImages,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
       });
+      await this.issueInterruptForReplyTarget(replyTo);
+      const result = await turnPromise;
+      this.activeTurnReplyTo = "";
       this.copilotLog(
         `runTurn completed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} answerLen=${String(
           result.text || "",
@@ -2582,6 +2947,10 @@ export class BridgeRunner {
         });
       }
       await this.syncBackendSessionBinding();
+      if (replyTo) {
+        this.clearInterruptRetryForReplyTarget(replyTo);
+        this.remoteInterruptsByReplyTo.delete(replyTo);
+      }
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
@@ -2600,6 +2969,7 @@ export class BridgeRunner {
         this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
       }
     } catch (error) {
+      this.activeTurnReplyTo = "";
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
         this.copilotLog(
@@ -2607,6 +2977,11 @@ export class BridgeRunner {
         );
         return;
       }
+      const interruptInfo = replyTo ? this.remoteInterruptsByReplyTo.get(replyTo) : null;
+      if (interruptInfo && this.isTurnInterruptedError(error)) {
+        await this.handleInterruptedTurn(replyTo, interruptInfo);
+        return;
+      }
       if (await this.settleCodexCheckpointUnavailableAfterStream(replyTo, errorMessage)) {
         return;
       }
@@ -2663,7 +3038,9 @@ export class BridgeRunner {
       }
       if (replyTo) {
         this.inFlightMessageIds.delete(replyTo);
+        this.clearInterruptRetryForReplyTarget(replyTo);
       }
+      this.activeTurnReplyTo = "";
       this.copilotLog(
         `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
       );