@@ -272,25 +272,31 @@ export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
       queuedRunId: input.queuedRunId,
       targetRunId: input.targetRunId,
     })),
-  wait_for_background_commands: (input) => {
-    const held = input.wait ?? true;
-    return dispatch(undefined, (common) => ({
-      ...common,
-      type: "thread.background-work.hold",
-      held,
-    })).pipe(
-      // The orchestrator rejects a hold when no background command runs.
-      Effect.mapError((error) =>
-        held && error.code === "orchestration_error"
-          ? new OrchestratorMcpFailure({
-              code: "invalid_request",
-              message:
-                "Could not wait: this thread has no background command running. Start the command in the background first.",
-            })
-          : error,
-      ),
-    );
-  },
+  wait_for_background_commands: (input) =>
+    Effect.gen(function* () {
+      const { threads, projection } = yield* readWritableThread();
+      const result = yield* threads
+        .dispatch({
+          type: "thread.background-work.hold",
+          commandId: yield* newCommandId(),
+          threadId: projection.thread.id,
+          held: input.wait ?? true,
+        })
+        .pipe(
+          // The orchestrator rejects a hold before commit only when no
+          // background command runs. Anything else stays retryable.
+          Effect.mapError((error) =>
+            error._tag === "OrchestratorCommandRejectedError"
+              ? new OrchestratorMcpFailure({
+                  code: "invalid_request",
+                  message:
+                    "Could not wait: this thread has no background command running. Start the command in the background first.",
+                })
+              : unavailable(),
+          ),
+        );
+      return { sequence: result.sequence };
+    }),
   t3_thread_organize: (input) =>
     Effect.gen(function* () {
       const { threads, projection } = yield* readWritableThread(input.threadId);
 
@@ -74,8 +74,10 @@ it.layer(testLayer)("thread.background-work.hold", (it) => {
         creationSource: "web",
       });
 
-      // Nothing runs yet, so there is nothing to wait for.
-      assert.equal((yield* Effect.exit(hold("hold-nothing", true)))._tag, "Failure");
+      // Nothing runs yet, so there is nothing to wait for. The MCP tool relies
+      // on this tag to tell the rejection apart from an outage.
+      const nothing = yield* Effect.flip(hold("hold-nothing", true));
+      assert.equal(nothing._tag, "OrchestratorCommandRejectedError");
 
       // The turn ended and left its benchmark running in the background.
       yield* projections.apply({
@@ -130,7 +132,11 @@ it.layer(testLayer)("thread.background-work.hold", (it) => {
           output: "",
         },
       });
-      const running = { taskId: "item:bench", description: "Run benchmarks", kind: "command" };
+      const running = {
+        taskId: "item:bench",
+        description: "Run benchmarks",
+        kind: "command" as const,
+      };
       assert.deepEqual((yield* projections.getThreadShell(threadId))?.pendingBackgroundTasks, [
         running,
       ]);
 
@@ -7851,8 +7851,9 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         activeProviderThreadId: thread.activeProviderThreadId,
         runs: projection.runs,
       }).flatMap((task) => (task.kind === "command" ? [task.taskId] : []));
+      // Its own tag, so the MCP tool can tell this apart from an outage.
       if (command.held && commandTaskIds.length === 0) {
-        return yield* new OrchestratorDispatchError({
+        return yield* new OrchestratorCommandRejectedError({
           commandId: command.commandId,
           commandType: command.type,
           cause: `Thread ${command.threadId} has no background commands running.`,
 
@@ -28,6 +28,15 @@ describe("summarizeT3ToolCalls", () => {
     ).toBe("Created 1 thread");
   });
 
+  it("names a release as the opposite of a wait for background commands", () => {
+    expect(summarizeT3ToolCalls("background-wait", [completed({})]).label).toBe(
+      "Set the thread to wait for background commands",
+    );
+    expect(summarizeT3ToolCalls("background-wait", [completed({ wait: false })]).label).toBe(
+      "Stopped waiting for background commands",
+    );
+  });
+
   it.each([
     ["queue-read", "Read 1 queued message"],
     ["queue-edit", "Edited 1 queued message"],
 
@@ -228,11 +228,9 @@ export function summarizeT3ToolCalls(
       label = phrase("Organized", "organize", `threads ${times}`);
       break;
     case "background-wait":
-      label = phrase(
-        "Set the thread to wait for",
-        "set the thread to wait for",
-        "background commands",
-      );
+      label = selected.every((call) => call.input?.wait === false)
+        ? phrase("Stopped waiting for", "stop waiting for", "background commands")
+        : phrase("Set the thread to wait for", "set the thread to wait for", "background commands");
       break;
     case "thread-update":
       label = phrase("Updated", "update", quantity(countEntities(threadIds), "thread"));
 
@@ -257,8 +257,9 @@ const T3_MCP_TOOLS: Readonly<Record<string, T3McpToolDefinition>> = {
   t3_thread_search: tool(["Search", "Searching", "Searched", "thread content"], "thread-search"),
   t3_thread_transfers: tool(["Read", "Reading", "Read", "thread transfers"], "thread-transfers"),
   t3_thread_organize: tool(["Organize", "Organizing", "Organized", "a thread"], "thread-organize"),
+  // One tool both waits and stops waiting (wait: false), so the labels stay neutral.
   wait_for_background_commands: tool(
-    ["Wait for", "Waiting for", "Waiting for", "background commands"],
+    ["Update", "Updating", "Updated", "background command waiting"],
     "background-wait",
   ),
   t3_thread_update: tool(["Update", "Updating", "Updated", "T3 thread metadata"], "thread-update"),