@@ -3349,6 +3349,7 @@ const make = Effect.gen(function* () {
           : {
               resultRun: { runId: result.resultRun.id, status: runOutcome(result.resultRun) },
             }),
+        ...(result.workState === undefined ? {} : { workState: result.workState }),
       } satisfies OrchestratorMcpThreadWaitResult;
     }),
     interruptThread: Effect.fn("OrchestratorMcpService.interruptThread")(function* (scope, input) {
 
@@ -127,7 +127,11 @@ const makeMacBook = (
     createdAt: "2026-10-22T03:40:00.000Z",
     updatedAt: "2026-10-22T03:44:00.000Z",
   });
+  let readsLeft = Infinity;
   const answer = (method: string, args: ReadonlyArray<any>): unknown => {
+    if (readsLeft <= 0 || (method === "getThread" && readsLeft-- <= 0)) {
+      throw new Error("The MacBook did not answer.");
+    }
     switch (method) {
       case "listEnvironments":
         return [
@@ -174,6 +178,10 @@ const makeMacBook = (
     calls,
     answer,
     called: (method: string) => calls.filter((call) => call.method === method),
+    /** Answers `reads` more thread reads, then nothing at all. */
+    stopAnsweringAfter: (reads: number) => {
+      readsLeft = reads;
+    },
   };
 };
 
@@ -508,6 +516,37 @@ it.effect("waiting on a remote child returns when its run completes", () => {
   }).pipe(Effect.provide(makeLayer(macbook, newRecord())));
 });
 
+it.effect("a remote wait reports an environment that stops answering instead of failing", () => {
+  const macbook = makeMacBook(["running"]);
+  return Effect.gen(function* () {
+    const clock = yield* makeSteppedClock;
+    const wait = orchestrate("t3_thread_wait", {
+      environmentId: macBook,
+      threadId: child,
+      timeoutMs: 60 * 60 * 1_000,
+    }).pipe(Effect.provideService(Clock.Clock, clock.stepped));
+    macbook.stopAnsweringAfter(1);
+    const fiber = yield* Effect.forkChild(wait);
+    // Each failed poll is tolerated until the last one.
+    expect([yield* clock.step, yield* clock.step, yield* clock.step]).toEqual([
+      1_000, 2_000, 4_000,
+    ]);
+    expect((yield* Fiber.join(fiber)).result).toMatchObject({
+      runId: "run-macbook-1",
+      status: "running",
+      timedOut: true,
+      unreachable: expect.stringContaining("did not answer"),
+    });
+    // Nothing seen yet: the wait still answers, with no run.
+    expect((yield* wait).result).toMatchObject({
+      runId: null,
+      status: "idle",
+      timedOut: true,
+      unreachable: expect.any(String),
+    });
+  }).pipe(Effect.provide(makeLayer(macbook, newRecord())));
+});
+
 it.effect("reads and sends reach a remote child through its environmentId", () => {
   const macbook = makeMacBook();
   return Effect.gen(function* () {
 
@@ -301,22 +301,32 @@ const stillActive = (remote: RemoteEnvironment, threadId: ThreadId, runId: RunId
  * The relaying app answers requests but streams nothing back, so a wait on another environment
  * polls, backing off to every five seconds. Each poll reads the small thread list and fetches
  * the thread itself only once its run is no longer the active one. Without runId, a restart
- * moves the wait to the run that continues the work, as a local wait does.
+ * moves the wait to the run that continues the work. A silent environment yields `unreachable`.
  */
 export const waitForThread = Effect.fn("remoteThreads.waitForThread")(function* (
   remote: RemoteEnvironment,
   input: OrchestratorMcpThreadWaitInput,
 ): Effect.fn.Return<OrchestratorMcpThreadWaitResult, OrchestratorMcpFailure> {
   const deadline = (yield* Clock.currentTimeMillis) + clampWaitTimeoutMs(input.timeoutMs);
-  let thread = yield* getRemoteThread(remote, input.threadId);
-  let runId = input.runId ?? thread.runs.at(-1)?.id;
+  let runId = input.runId;
   const result = (status: OrchestratorMcpThreadWaitResult["status"], timedOut: boolean) => ({
     environmentId: remote.environmentId,
     threadId: input.threadId,
     runId: runId ?? null,
     status,
     timedOut,
   });
+  const unreachable = (
+    status: OrchestratorMcpThreadWaitResult["status"],
+    failure: OrchestratorMcpFailure,
+  ) =>
+    failure.code === "orchestration_error"
+      ? Effect.succeed({ ...result(status, true), unreachable: failure.message })
+      : Effect.fail(failure);
+  const first = yield* getRemoteThread(remote, input.threadId).pipe(Effect.result);
+  if (first._tag === "Failure") return yield* unreachable("idle", first.failure);
+  let thread = first.success;
+  runId ??= thread.runs.at(-1)?.id;
   if (runId === undefined) return result("idle", false);
   let delay = FIRST_POLL;
   let failures = 0;
@@ -350,7 +360,7 @@ export const waitForThread = Effect.fn("remoteThreads.waitForThread")(function*
       thread = next.success;
       failures = 0;
     } else if (++failures >= RELAY_FAILURES_TOLERATED) {
-      return yield* next.failure;
+      return yield* unreachable(run.status, next.failure);
     }
   }
 });
 
@@ -293,7 +293,7 @@ const ThreadSendTool = Tool.make("t3_thread_send", {
 
 const ThreadWaitTool = Tool.make("t3_thread_wait", {
   description:
-    "Wait for a T3 thread run to reach a terminal durable state. Pass environmentId for a thread on another environment. Without runId, the latest run at call time is selected; an idle thread returns immediately. A thread blocked on a question returns early with hasPendingQuestion and pendingRequestId for t3_pending_request, or on an approval with pendingApproval. Timeout does not interrupt work, so call again or use t3_thread_read/list after timedOut=true. Waiting reports status only and does not acknowledge a delegated result.",
+    "Wait for a T3 thread run to reach a terminal durable state. Pass environmentId for a thread on another environment. Without runId, the latest run at call time is selected; an idle thread returns immediately. A thread blocked on a question returns early with hasPendingQuestion and pendingRequestId for t3_pending_request, or on an approval with pendingApproval. Timeout does not interrupt work, so call again or use t3_thread_read/list after timedOut=true. With untilDelegatedWorkSettled, a terminal status with timedOut=true means the run ended but the thread is not done; workState says why. Waiting reports status only and does not acknowledge a delegated result.",
   parameters: OrchestratorMcpThreadWaitInput,
   success: OrchestratorMcpThreadWaitResult,
   failure: OrchestratorMcpFailure,
 
@@ -3368,9 +3368,12 @@ it.layer(layerTest)("delegated tasks across a server restart", (it) => {
                 occurredAt: now,
                 payload: {
                   ...providerThread,
-                  pendingBackgroundTasks: open
-                    ? [{ taskId: "sleep-900", kind: "command" as const }]
-                    : [],
+                  pendingBackgroundTasks: [
+                    ...(open
+                      ? [{ taskId: "sleep-900", kind: "command" as const, awaited: true as const }]
+                      : []),
+                    { taskId: "log-watcher", kind: "monitor" as const },
+                  ],
                 },
               }
             : {
 
@@ -81,6 +81,7 @@ import {
 import { modelSelectionsEqual } from "@t3tools/shared/model";
 import { recordThreadOpen } from "@t3tools/shared/paletteSearch";
 import {
+  backgroundWorkHoldsCompletion,
   derivePendingBackgroundWork,
   pendingBackgroundTurnItems,
   turnItemUpdateCanEndBackgroundWork,
@@ -14152,14 +14153,14 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
 
   // A child whose run ends while its background tasks or its own subagents still run has no
   // result yet. When that work settles there is no run update to finalize it, so these events
-  // do it. A background roster counts once it empties after it was seen non-empty.
+  // do it. A background roster counts once it stops holding after it was seen holding.
   const providerThreadsWithBackgroundWork = new Set<string>();
   const settlesChildWork = (stored: OrchestrationV2StoredEvent) => {
     const { event } = stored;
     if (event.type === "subagent.updated")
       return !isOrchestrationV2WorkActive(event.payload.status);
     if (event.type !== "provider-thread.updated") return false;
-    if ((event.payload.pendingBackgroundTasks?.length ?? 0) > 0) {
+    if (backgroundWorkHoldsCompletion(event.payload.pendingBackgroundTasks ?? [])) {
       providerThreadsWithBackgroundWork.add(event.payload.id);
       return false;
     }
 
@@ -272,15 +272,25 @@ it("waits for nested work and retains the report across monitor acknowledgements
       "result_available",
     );
   }
-  assert.equal(
-    delegatedTaskProgress({
-      ...projection,
-      providerThreads: [
-        { pendingBackgroundTasks: [{ taskId: "background-audit", kind: "command" }] },
-      ],
-    }).state,
-    "waiting_for_children",
-  );
+  for (const [awaited, state] of [
+    [true, "waiting_for_children"],
+    [false, "result_available"],
+  ] as const) {
+    assert.equal(
+      delegatedTaskProgress({
+        ...projection,
+        providerThreads: [
+          {
+            pendingBackgroundTasks: [
+              { taskId: "background-audit", kind: "command", ...(awaited ? { awaited } : {}) },
+              { taskId: "log-watcher", kind: "monitor" },
+            ],
+          },
+        ],
+      }).state,
+      state,
+    );
+  }
   const pending = {
     ...run,
     id: RunId.make("followup"),
 
@@ -406,7 +406,7 @@ it.effect("waitForThread can wait past an ended run for the thread's delegated w
     const threadId = ThreadId.make("thread:thread-management:wait-delegated");
     const runId = RunId.make("run:thread-management:wait-delegated");
     const wakeRunId = RunId.make("run:thread-management:wait-delegated:wake");
-    const subscribed = yield* Deferred.make<void>();
+    let subscribed = yield* Deferred.make<void>();
     const events = yield* Queue.unbounded<OrchestrationV2StoredEvent>();
     const at = (seconds: number) => DateTime.makeUnsafe(seconds * 1_000);
     const run = (id: RunId, ordinal: number, status: OrchestrationV2Run["status"], end: number) =>
@@ -464,6 +464,31 @@ it.effect("waitForThread can wait past an ended run for the thread's delegated w
       yield* service.waitForThread({ projectId, threadId, runId, timeoutMs: 60 * 60 * 1_000 }),
     ).not.toHaveProperty("resultRun");
 
+    // A wait that runs out says why the ended run is not the answer yet.
+    const timedOut = Effect.fnUntraced(function* () {
+      const waiting = yield* service
+        .waitForThread({
+          projectId,
+          threadId,
+          runId,
+          timeoutMs: 1_000,
+          untilDelegatedWorkSettled: true,
+        })
+        .pipe(Effect.forkChild);
+      yield* TestClock.adjust(Duration.millis(1_000));
+      return yield* Fiber.join(waiting);
+    });
+    expect(yield* timedOut()).toMatchObject({
+      timedOut: true,
+      run: { id: runId, status: "completed" },
+      workState: "waiting_for_children",
+    });
+    // The task finishes; its delivery wakes the thread, whose next run answers.
+    subagents = [{ status: "completed" }];
+    runs = [...runs, run(wakeRunId, 2, "running", 3)];
+    expect(yield* timedOut()).toMatchObject({ timedOut: true, workState: "working" });
+
+    subscribed = yield* Deferred.make<void>();
     const fiber = yield* service
       .waitForThread({
         projectId,
@@ -475,16 +500,15 @@ it.effect("waitForThread can wait past an ended run for the thread's delegated w
       .pipe(Effect.forkChild);
     // A wait that returns early fails below instead of hanging here.
     yield* Effect.raceFirst(Deferred.await(subscribed), Fiber.await(fiber));
-    // The task finishes; its delivery wakes the thread, whose next run answers.
-    subagents = [{ status: "completed" }];
-    runs = [...runs, run(wakeRunId, 2, "completed", 3)];
+    runs = [runs[0]!, run(wakeRunId, 2, "completed", 3)];
     yield* Queue.offer(events, stored(1, { type: "subagent.updated", payload: {} }));
     const result = yield* Fiber.join(fiber);
 
     expect(result).toMatchObject({
       timedOut: false,
       run: { id: runId, status: "completed" },
       resultRun: { id: wakeRunId, status: "completed" },
+      workState: "result_available",
     });
   }),
 );
 
@@ -197,6 +197,12 @@ export interface ThreadManagementWaitResult {
   readonly timedOut: boolean;
   /** With `untilDelegatedWorkSettled`, once settled: the run with the thread's final answer. */
   readonly resultRun?: OrchestrationV2Run;
+  /**
+   * With `untilDelegatedWorkSettled`, once the selected run ended: `working` while
+   * another run continues the thread, `waiting_for_children` while its tasks or
+   * awaited background work remain, `result_available` once settled.
+   */
+  readonly workState?: ReturnType<typeof delegatedTaskProgress>["state"];
   /** With `untilQuestion`: the live question the thread is blocked on. */
   readonly pendingQuestion?: RuntimeRequestId;
   /** With `untilQuestion`: the oldest live approval the thread is blocked on. */
@@ -1117,13 +1123,18 @@ const make = Effect.gen(function* () {
         progress.resultRun === undefined &&
         records.runs.every((run) => isTerminalRunStatus(run.status))
       ) {
-        return latestRun(records);
+        return { workState: "result_available" as const, resultRun: latestRun(records) };
+      }
+      if (progress.state !== "result_available") {
+        return { workState: progress.state, resultRun: undefined };
       }
-      if (progress.state !== "result_available") return undefined;
+      // A pending result is a restart continuation or delivery about to run.
       const pending = yield* orchestrator
         .delegatedTaskResultPending(input.threadId)
         .pipe(Effect.mapError(loadError));
-      return pending ? undefined : progress.resultRun;
+      return pending
+        ? { workState: "working" as const, resultRun: undefined }
+        : { workState: progress.state, resultRun: progress.resultRun };
     });
     const untilQuestion = input.untilQuestion === true;
     const blockingRequests = getProjectThreadRecords(input, ["runtimeRequests"]).pipe(
@@ -1153,13 +1164,13 @@ const make = Effect.gen(function* () {
       const current =
         outcomeNow.settled && untilDelegatedWorkSettled
           ? yield* delegatedWorkResult.pipe(
-              Effect.map((resultRun) => ({
+              Effect.map((delegated) => ({
                 ...outcomeNow,
-                settled: resultRun !== undefined,
-                resultRun,
+                ...delegated,
+                settled: delegated.resultRun !== undefined,
               })),
             )
-          : { ...outcomeNow, resultRun: undefined };
+          : { ...outcomeNow, resultRun: undefined, workState: undefined };
       const blocked =
         current.settled || !untilQuestion
           ? { pendingQuestion: undefined, pendingApproval: undefined }
@@ -1178,6 +1189,7 @@ const make = Effect.gen(function* () {
       run: current.run,
       timedOut: !current.done,
       ...(current.resultRun === undefined ? {} : { resultRun: current.resultRun }),
+      ...(current.workState === undefined ? {} : { workState: current.workState }),
       ...(current.pendingQuestion === undefined
         ? {}
         : { pendingQuestion: current.pendingQuestion }),
 
@@ -62,6 +62,8 @@ interface Seen {
   readonly clones: ReadonlyArray<SourceControlCloneRepositoryInput>;
   /** Commands dispatched and delegated-task stops, as `<type> <threadId>`. */
   readonly stops: ReadonlyArray<string>;
+  /** Waits, counted from 1, that fail as a peer that stops answering would. */
+  readonly droppedWaits?: ReadonlyArray<number>;
 }
 const nothingSeen: Seen = {
   sends: [],
@@ -137,11 +139,21 @@ const boxThreads = (seen: Ref.Ref<Seen>, linkSession: Ref.Ref<string>) => {
       })),
     waitForThread: (input) =>
       Ref.updateAndGet(seen, (current) => ({ ...current, waits: [...current.waits, input] })).pipe(
-        Effect.map(({ waits }) => ({
-          threadId: input.threadId,
-          run: run(waits.length < 3 ? "running" : "completed"),
-          timedOut: waits.length < 3,
-        })),
+        Effect.flatMap(({ waits, droppedWaits }) =>
+          droppedWaits?.includes(waits.length)
+            ? Effect.fail(
+                new ThreadManagement.ThreadManagementProjectionLoadError({
+                  projectId: boxProject,
+                  threadId: input.threadId,
+                  cause: "dropped",
+                }),
+              )
+            : Effect.succeed({
+                threadId: input.threadId,
+                run: run(waits.length < 3 ? "running" : "completed"),
+                timedOut: waits.length < 3,
+              }),
+        ),
       ),
   });
 };
@@ -549,6 +561,37 @@ it.effect("keeps a forwarded wait short and its retries scoped to the caller", (
   ).pipe(Effect.provide(NodeHttpServer.layerTest)),
 );
 
+it.effect("reports a linked environment that stops answering mid-wait instead of failing", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const seen = yield* Ref.make<Seen>({ ...nothingSeen, droppedWaits: [2] });
+      const linkSession = yield* Ref.make("");
+      const b = yield* serveBox(seen, linkSession);
+      const a = yield* makeLaptop;
+      yield* linkTo(a.links, b, "auto");
+      yield* Ref.set(linkSession, (yield* b.linkedSessions)[0]!.sessionId);
+      const wait = a.call("thread:laptop-full", "t3_thread_wait", {
+        environmentId: box.environmentId,
+        threadId: boxThread,
+        timeoutMs: 600_000,
+      });
+
+      const dropped = yield* wait;
+      expect(dropped.isError).toBe(false);
+      expect(dropped.structuredContent).toMatchObject({
+        runId: boxRun,
+        status: "running",
+        timedOut: true,
+        unreachable: expect.any(String),
+      });
+      expect((yield* wait).structuredContent).toMatchObject({
+        status: "completed",
+        timedOut: false,
+      });
+    }),
+  ).pipe(Effect.provide(NodeHttpServer.layerTest)),
+);
+
 it.effect("launches in a linked environment with the caller's modes, retry-safe", () =>
   Effect.scoped(
     Effect.gen(function* () {