@@ -7,6 +7,7 @@ import * as Layer from "effect/Layer";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as HttpClient from "effect/http/HttpClient";
+import { ChildProcessSpawner } from "effect/process";
 import * as NetService from "@t3tools/shared/Net";
 import * as Fiber from "effect/Fiber";
 import * as Option from "effect/Option";
@@ -213,6 +214,7 @@ it.effect.each([false, true])(
         Effect.provide(
           Layer.mergeAll(
             Layer.mock(BrowserImport.BrowserImport, {}),
+            Layer.mock(ChildProcessSpawner.ChildProcessSpawner, {}),
             Layer.mock(DesktopBackendConfiguration.DesktopBackendConfiguration, {}),
             Layer.mock(DesktopCliCommand.DesktopCliCommand, {}),
             Layer.mock(DesktopClientSettings.DesktopClientSettings, {}),
 
@@ -421,7 +421,7 @@ describe("DesktopBackendManager", () => {
     ),
   );
 
-  it.effect("starts the configured backend and closes the scoped process on stop", () =>
+  it.effect("stops the scoped process with output still pending", () =>
     Effect.scoped(
       Effect.gen(function* () {
         let startCount = 0;
@@ -458,6 +458,7 @@ describe("DesktopBackendManager", () => {
               yield* Scope.addFinalizer(scope, close);
 
               return makeProcess({
+                stdout: Stream.never,
                 exitCode: Deferred.await(closed).pipe(Effect.as(ChildProcessSpawner.ExitCode(0))),
                 kill: () => close,
               });
@@ -721,14 +722,12 @@ describe("DesktopBackendManager", () => {
     ),
   );
 
-  it.effect("the quit stop deadline waits for a backend that only exits at the force kill", () =>
+  it.effect("the quit stop keeps waiting for a backend that outlasts its deadline", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const spawned = yield* Deferred.make<void>();
         const teardownStarted = yield* Deferred.make<void>();
         const teardownFinished = yield* Deferred.make<void>();
-        // The real spawner sends SIGTERM, waits the grace, then SIGKILLs. A backend that
-        // ignores SIGTERM therefore finishes tearing down just after the grace.
         const instance = yield* makeTestInstance({
           spawnerLayer: Layer.succeed(
             ChildProcessSpawner.ChildProcessSpawner,
@@ -739,7 +738,7 @@ describe("DesktopBackendManager", () => {
                 yield* Scope.addFinalizer(
                   scope,
                   Deferred.succeed(teardownStarted, undefined).pipe(
-                    Effect.andThen(Effect.sleep(Duration.seconds(6))),
+                    Effect.andThen(Effect.sleep(Duration.seconds(10))),
                     Effect.andThen(Deferred.succeed(teardownFinished, undefined)),
                     Effect.asVoid,
                   ),
@@ -764,11 +763,11 @@ describe("DesktopBackendManager", () => {
           .pipe(Effect.andThen(Deferred.succeed(quitDone, undefined)), Effect.forkChild);
 
         yield* Deferred.await(teardownStarted);
-        // Past the SIGTERM grace but before the force kill lands: quit must still be waiting.
-        yield* TestClock.adjust(Duration.millis(5_500));
+        // Past the quit deadline, quit must still wait for the backend to exit.
+        yield* TestClock.adjust(Duration.seconds(9));
         assert.isFalse(yield* Deferred.isDone(quitDone));
 
-        yield* TestClock.adjust(Duration.millis(500));
+        yield* TestClock.adjust(Duration.seconds(1));
         yield* Fiber.join(quitFiber);
         assert.isTrue(yield* Deferred.isDone(teardownFinished));
       }).pipe(Effect.provide(TestClock.layer())),
 
@@ -240,6 +240,7 @@ export interface DesktopBackendInstance {
   readonly id: BackendInstanceId;
   readonly label: Effect.Effect<string>;
   readonly start: Effect.Effect<void>;
+  /** Timeout controls the warning; stop still waits for process teardown and exit. */
   readonly stop: (options?: { readonly timeout?: Duration.Duration }) => Effect.Effect<void>;
   readonly currentConfig: Effect.Effect<Option.Option<DesktopBackendStartConfig>>;
   readonly snapshot: Effect.Effect<DesktopBackendSnapshot>;
@@ -307,7 +308,7 @@ const closeRun = (
   run: ActiveBackendRun,
   parentScope: Scope.Scope,
   options?: { readonly timeout?: Duration.Duration },
-): Effect.Effect<boolean> => {
+) => {
   const waitForFiber = Option.match(run.fiber, {
     onNone: () => Effect.void,
     onSome: (fiber) => Fiber.await(fiber).pipe(Effect.asVoid),
@@ -319,12 +320,24 @@ const closeRun = (
   const timeout = options?.timeout;
 
   if (!timeout) {
-    return close.pipe(Effect.as(true));
+    return close;
   }
 
-  return Effect.forkIn(close, parentScope).pipe(
+  return Effect.forkIn(close, parentScope, { startImmediately: true }).pipe(
     Effect.flatMap((closeFiber) =>
-      Fiber.await(closeFiber).pipe(Effect.timeoutOption(timeout), Effect.map(Option.isSome)),
+      Fiber.await(closeFiber).pipe(
+        Effect.timeoutOption(timeout),
+        Effect.tap((completed) =>
+          Option.isNone(completed)
+            ? logBackendProcessWarning("backend shutdown exceeded timeout; waiting for exit", {
+                timeoutMs: Duration.toMillis(timeout),
+              })
+            : Effect.void,
+        ),
+        // Parent-scope interruption still finishes release; do not cancel sibling stops.
+        Effect.andThen(Fiber.await(closeFiber)),
+        Effect.asVoid,
+      ),
     ),
   );
 };
@@ -1099,10 +1112,7 @@ export const makeBackendInstance = Effect.fn("makeBackendInstance")(function* (
       onNone: () => Effect.void,
       // The enclosing operation owns the span for this inline handler.
       onSome: Effect.fnUntraced(function* (run) {
-        const closed = yield* closeRun(run, parentScope, options);
-        if (!closed) {
-          return;
-        }
+        yield* closeRun(run, parentScope, options);
         const cleanup = yield* mutex.withPermits(1)(
           SubscriptionRef.modify(
             state,
 
@@ -1,11 +1,17 @@
 import { assert, describe, it } from "@effect/vitest";
+import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Queue from "effect/Queue";
+import * as TestClock from "effect/testing/TestClock";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
+import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
-import { HttpClient } from "effect/http";
+import { HttpClient, HttpClientResponse } from "effect/http";
 import { ChildProcessSpawner } from "effect/process";
 
 import * as DesktopObservability from "../app/DesktopObservability.ts";
@@ -21,18 +27,105 @@ import * as DesktopBackendConfiguration from "./DesktopBackendConfiguration.ts";
 import * as DesktopBackendPool from "./DesktopBackendPool.ts";
 import type { DesktopBackendStartConfig } from "./DesktopBackendManager.ts";
 
-function layerPool(labelRef: Ref.Ref<string>): Layer.Layer<DesktopBackendPool.DesktopBackendPool> {
+// Models the spawner's release for a backend that ignores SIGTERM, without OS signals.
+const makeFakeBackendProcess = Effect.fn("test.makeFakeBackendProcess")(function* () {
+  const started = yield* Deferred.make<void>();
+  const exited = yield* Deferred.make<ChildProcessSpawner.ExitCode>();
+  const signals = yield* Queue.unbounded<"SIGTERM" | "SIGKILL">();
+  let running = false;
+  const killWait = Duration.seconds(1);
+  const exit = Effect.sync(() => {
+    running = false;
+  }).pipe(Effect.andThen(Deferred.succeed(exited, ChildProcessSpawner.ExitCode(0))), Effect.asVoid);
+  const layer = Layer.succeed(
+    ChildProcessSpawner.ChildProcessSpawner,
+    ChildProcessSpawner.make((command) =>
+      Effect.gen(function* () {
+        if (command._tag !== "StandardCommand") {
+          return yield* Effect.die("Expected a standard backend command");
+        }
+        const terminateGrace = Duration.fromInputUnsafe(command.options.forceKillAfter ?? 0);
+        running = true;
+        yield* Effect.addFinalizer(() =>
+          Effect.gen(function* () {
+            yield* Queue.offer(signals, "SIGTERM");
+            yield* Effect.sleep(terminateGrace);
+            yield* Queue.offer(signals, "SIGKILL");
+            yield* Effect.sleep(killWait);
+            yield* exit;
+          }),
+        );
+        yield* Deferred.succeed(started, undefined);
+        return ChildProcessSpawner.makeHandle({
+          pid: ChildProcessSpawner.ProcessId(123),
+          stdout: Stream.empty,
+          stderr: Stream.empty,
+          all: Stream.empty,
+          stdin: Sink.drain,
+          getInputFd: () => Sink.drain,
+          getOutputFd: () => Stream.empty,
+          exitCode: Deferred.await(exited),
+          isRunning: Effect.sync(() => running),
+          kill: () => exit,
+          unref: Effect.succeed(Effect.void),
+        });
+      }),
+    ),
+  );
+  return {
+    layer,
+    started: Deferred.await(started),
+    signals,
+    isRunning: Effect.sync(() => running),
+    killWait,
+  };
+});
+
+const runningConfig = {
+  executablePath: "/electron",
+  args: [],
+  entryPath: "/server/bin.mjs",
+  cwd: "/server",
+  env: {},
+  bootstrap: {
+    mode: "desktop",
+    noBrowser: true,
+    port: 3774,
+    t3Home: "/tmp/t3",
+    host: "127.0.0.1",
+    desktopBootstrapToken: "token",
+    tailscaleServeEnabled: false,
+    tailscaleServePort: 443,
+  },
+  bootstrapDelivery: "fd3",
+  extendEnv: true,
+  httpBaseUrl: new URL("http://127.0.0.1:3774"),
+  captureOutput: false,
+  preflightFailure: Option.none(),
+} satisfies DesktopBackendStartConfig;
+
+function layerPool(
+  labelRef: Ref.Ref<string>,
+  backend?: Effect.Success<ReturnType<typeof makeFakeBackendProcess>>,
+): Layer.Layer<DesktopBackendPool.DesktopBackendPool> {
   return DesktopBackendPool.layer.pipe(
     Layer.provideMerge(
       Layer.mergeAll(
-        FileSystem.layerNoop({}),
-        Layer.succeed(
-          ChildProcessSpawner.ChildProcessSpawner,
-          ChildProcessSpawner.make(() => Effect.die("unexpected child process spawn")),
-        ),
+        FileSystem.layerNoop({ exists: () => Effect.succeed(true) }),
+        backend?.layer ??
+          Layer.succeed(
+            ChildProcessSpawner.ChildProcessSpawner,
+            ChildProcessSpawner.make(() => Effect.die("unexpected child process spawn")),
+          ),
         Layer.succeed(
           HttpClient.HttpClient,
-          HttpClient.make(() => Effect.die("unexpected HTTP request")),
+          HttpClient.make((request) =>
+            backend === undefined
+              ? Effect.die("unexpected HTTP request")
+              : Effect.succeed(
+                  HttpClientResponse.fromWeb(request, new Response(null, { status: 200 })),
+                ),
+          ),
         ),
         Layer.succeed(DesktopObservability.DesktopBackendOutputLogFactory, {
           forInstance: () =>
@@ -90,6 +183,62 @@ function layerPool(labelRef: Ref.Ref<string>): Layer.Layer<DesktopBackendPool.De
 }
 
 describe("DesktopBackendPool", () => {
+  it.effect("unregister during pool quit does not interrupt sibling stops", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const backend = yield* makeFakeBackendProcess();
+        yield* Effect.gen(function* () {
+          const pool = yield* DesktopBackendPool.DesktopBackendPool;
+          const id = DesktopBackendPool.BackendInstanceId("wsl:Ubuntu");
+          const ready = yield* Deferred.make<void>();
+          const siblingStarted = yield* Deferred.make<void>();
+          const finishSibling = yield* Deferred.make<void>();
+          let siblingCompleted = false;
+          const instance = yield* pool.register({
+            id,
+            label: Effect.succeed("WSL (Ubuntu)"),
+            configResolve: Effect.succeed(runningConfig),
+            onReady: () => Deferred.succeed(ready, undefined).pipe(Effect.asVoid),
+          });
+          yield* instance.start;
+          yield* backend.started;
+          yield* Deferred.await(ready);
+          const quitFiber = yield* Effect.all(
+            [
+              instance.stop({ timeout: Duration.seconds(5) }),
+              Deferred.succeed(siblingStarted, undefined).pipe(
+                Effect.andThen(Deferred.await(finishSibling)),
+                Effect.andThen(
+                  Effect.sync(() => {
+                    siblingCompleted = true;
+                  }),
+                ),
+              ),
+            ],
+            { concurrency: "unbounded" },
+          ).pipe(Effect.forkChild);
+          yield* Deferred.await(siblingStarted);
+          assert.equal(yield* Queue.take(backend.signals), "SIGTERM");
+          const unregisterFiber = yield* pool.unregister(id).pipe(Effect.forkChild);
+          yield* TestClock.adjust(Duration.seconds(5));
+          assert.equal(yield* Queue.take(backend.signals), "SIGKILL");
+          assert.isUndefined(quitFiber.pollUnsafe());
+          assert.isUndefined(unregisterFiber.pollUnsafe());
+          assert.isTrue(yield* backend.isRunning);
+          yield* TestClock.adjust(backend.killWait);
+          yield* Fiber.join(unregisterFiber);
+          yield* Deferred.succeed(finishSibling, undefined);
+          yield* Fiber.join(quitFiber);
+
+          assert.isTrue(siblingCompleted);
+          assert.isFalse(yield* backend.isRunning);
+          assert.isTrue(Option.isNone((yield* instance.snapshot).activePid));
+          assert.isTrue(Option.isNone(yield* pool.get(id)));
+        }).pipe(Effect.provide(layerPool(Ref.makeUnsafe("Windows"), backend)));
+      }),
+    ),
+  );
+
   it.effect("unregister stops the registered instance", () =>
     Effect.scoped(
       Effect.gen(function* () {
@@ -99,27 +248,9 @@ describe("DesktopBackendPool", () => {
           id,
           label: Effect.succeed("WSL (Ubuntu)"),
           configResolve: Effect.succeed({
-            executablePath: "/electron",
-            args: [],
-            entryPath: "/server/bin.mjs",
-            cwd: "/server",
-            env: {},
-            bootstrap: {
-              mode: "desktop",
-              noBrowser: true,
-              port: 3774,
-              t3Home: "/tmp/t3",
-              host: "127.0.0.1",
-              desktopBootstrapToken: "token",
-              tailscaleServeEnabled: false,
-              tailscaleServePort: 443,
-            },
-            bootstrapDelivery: "fd3",
-            extendEnv: true,
-            httpBaseUrl: new URL("http://127.0.0.1:3774"),
-            captureOutput: false,
+            ...runningConfig,
             preflightFailure: Option.some({ reason: "WSL starting", fatal: false }),
-          } satisfies DesktopBackendStartConfig),
+          }),
         });
         yield* instance.start;
         assert.equal((yield* instance.snapshot).restartScheduled, true);
 
@@ -75,7 +75,10 @@ function normalizeContextMenuItems(source: readonly ContextMenuItem[]): ContextM
 
     const normalizedItem: ContextMenuItem = {
       id: sourceItem.id,
-      label: sourceItem.label,
+      label:
+        typeof sourceItem.detail === "string" && sourceItem.detail.length > 0
+          ? `${sourceItem.label} (${sourceItem.detail})`
+          : sourceItem.label,
       destructive: sourceItem.destructive === true,
       disabled: sourceItem.disabled === true,
       ...(sourceItem.separatorBefore === true ? { separatorBefore: true } : {}),