@@ -32,7 +32,10 @@ import {
   ProviderInteractionMode,
   RuntimeMode,
 } from "@t3tools/contracts";
-import { deriveThreadTitleSeed } from "@t3tools/client-runtime/operations";
+import {
+  deriveThreadTitleSeed,
+  ThreadLaunchUnansweredError,
+} from "@t3tools/client-runtime/operations";
 import { wasBootstrapThreadDeleted } from "@t3tools/client-runtime/errors";
 import {
   declinePendingApprovals,
@@ -51,6 +54,7 @@ import {
 import { createModelSelection } from "@t3tools/shared/model";
 import { type SetStateAction, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { flushSync } from "react-dom";
+import * as Schema from "effect/Schema";
 import { useNavigate } from "@tanstack/react-router";
 import {
   isAtomCommandInterrupted,
@@ -264,6 +268,8 @@ interface ComposerSendInput {
   readonly linkCheckoutPullRequest: (threadRef: ScopedThreadRef, url: string) => void;
 }
 
+const isThreadLaunchUnanswered = Schema.is(ThreadLaunchUnansweredError);
+
 const notifyQueuedSubmitNotSent = () =>
   toastManager.add(
     stackedThreadToast({
@@ -1419,14 +1425,16 @@ export function useComposerSend(input: ComposerSendInput) {
     }
 
     if (failure !== null) {
+      const failureError = squashAtomCommandFailure(failure);
+      // An unanswered launch may still create the thread, so the draft stays promoted to it.
       if (isLocalDraftThread && draftId && draftThread) {
-        restoreFailedDraftThread(
-          draftId,
-          draftThread,
-          wasBootstrapThreadDeleted(squashAtomCommandFailure(failure))
-            ? newThreadId()
-            : threadIdForSend,
-        );
+        if (!isThreadLaunchUnanswered(failureError)) {
+          restoreFailedDraftThread(
+            draftId,
+            draftThread,
+            wasBootstrapThreadDeleted(failureError) ? newThreadId() : threadIdForSend,
+          );
+        }
         clearBackgroundDraftSubmissionByRef(scopeThreadRef(environmentId, threadIdForSend));
       }
       // Only an acknowledged send replaces its optimistic row, so a failed one leaves here.
@@ -1481,10 +1489,9 @@ export function useComposerSend(input: ComposerSendInput) {
         }
       }
       if (!isAtomCommandInterrupted(failure)) {
-        const error = squashAtomCommandFailure(failure);
         setThreadError(
           threadIdForSend,
-          error instanceof Error ? error.message : "Failed to send message.",
+          failureError instanceof Error ? failureError.message : "Failed to send message.",
         );
         if (
           draftId &&
@@ -1497,7 +1504,8 @@ export function useComposerSend(input: ComposerSendInput) {
                 submissionIntent === "background"
                   ? "Background task failed"
                   : "Could not start thread",
-              description: error instanceof Error ? error.message : "Failed to send message.",
+              description:
+                failureError instanceof Error ? failureError.message : "Failed to send message.",
               actionProps: {
                 children: "Open draft",
                 onClick: () => {
 
@@ -505,7 +505,7 @@ describe("V2 environment commands", () => {
       expect(sendFiber.pollUnsafe()).toBeUndefined();
       yield* TestClock.adjust("1 second");
 
-      expect((yield* Fiber.join(sendFiber))._tag).toBe("EnvironmentRpcUnavailableError");
+      expect((yield* Fiber.join(sendFiber))._tag).toBe("ThreadLaunchUnansweredError");
       // The server commits a launch in several steps, so the late request keeps running.
       expect(interrupted).toBe(false);
     }).pipe(Effect.provide(layerTestRandom)),
 
@@ -36,6 +36,7 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
 import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import * as SubscriptionRef from "effect/SubscriptionRef";
 
@@ -350,14 +351,18 @@ const dispatchMessage = Effect.fn("EnvironmentCommands.dispatchMessage")(functio
   }
 });
 
+export class ThreadLaunchUnansweredError extends Schema.TaggedError<ThreadLaunchUnansweredError>()(
+  "ThreadLaunchUnansweredError",
+  { message: Schema.String },
+) {}
+
 // Interrupting a launch would cancel the server handler mid-launch, so the deadline bounds only
-// the wait and the launch keeps running; the error says the message may still arrive.
+// the wait and the launch keeps running; the server may still create the thread.
 const THREAD_LAUNCH_TIMEOUT = "2 minutes";
 
 const launchThread = Effect.fn("EnvironmentCommands.launchThread")(function* (
   input: EnvironmentRpcInput<typeof ORCHESTRATION_V2_WS_METHODS.launchThread>,
 ) {
-  const supervisor = yield* EnvironmentSupervisor.EnvironmentSupervisor;
   const answer = yield* Effect.forkDetach(
     request(ORCHESTRATION_V2_WS_METHODS.launchThread, input),
     {
@@ -369,9 +374,9 @@ const launchThread = Effect.fn("EnvironmentCommands.launchThread")(function* (
       duration: THREAD_LAUNCH_TIMEOUT,
       orElse: () =>
         Effect.fail(
-          new EnvironmentRpcUnavailableError({
-            environmentId: supervisor.target.environmentId,
-            message: `${supervisor.target.label} did not confirm the message within 2 minutes. It may still arrive; check the thread before sending it again.`,
+          new ThreadLaunchUnansweredError({
+            message:
+              "The server did not confirm this message. It may still arrive; check the thread before sending it again.",
           }),
         ),
     }),