coder
diff --git a/‎src/node/orpc/router.ts‎
Lines changed: 1 addition & 1 deletion b/‎src/node/orpc/router.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/node/services/muxGatewayOauthService.ts‎
Lines changed: 7 additions & 5 deletions b/‎src/node/services/muxGatewayOauthService.ts‎
Lines changed: 7 additions & 5 deletions
diff --git a/‎src/node/utils/oauthFlowManager.test.ts‎
Lines changed: 68 additions & 0 deletions b/‎src/node/utils/oauthFlowManager.test.ts‎
Lines changed: 68 additions & 0 deletions
@@ -579,7 +579,7 @@ export const router = (authToken?: string) => {
       // startDesktopFlow rides handlerGen; its service pipeline is
       // uninterruptible (see startDesktopFlowEffect) so a client abort cannot
       // leak the loopback server. waitFor/cancel stay plain handlers until the
-      // promise-native OAuthFlowManager grows an Effect surface.
+      // batch OAuth-service conversion migrates the remaining procedures.
       startDesktopFlow: t
         .input(schemas.muxGatewayOauth.startDesktopFlow.input)
         .output(schemas.muxGatewayOauth.startDesktopFlow.output)
 
@@ -11,9 +11,9 @@
  * is already the exact user-facing string.
  *
  * Desktop flow bookkeeping (deferreds, loopback server lifetime, timeouts)
- * stays promise-based in `OAuthFlowManager`, which is shared with the other
- * OAuth services — converting that lifecycle to Effect `Scope` is deferred
- * until the shared manager itself migrates.
+ * lives in `OAuthFlowManager`, which is shared with the other OAuth services
+ * and is itself Effect-native (per-flow `Scope` lifecycle) — Effect callers
+ * here use its `*Effect` surface directly.
  */
 import * as crypto from "crypto";
 import { Effect, Schema } from "effect";
@@ -295,7 +295,9 @@ export class MuxGatewayOauthService {
         // Keep server-side timeout tied to flow lifetime so abandoned flows
         // (e.g. callers that never invoke waitForDesktopFlow) still self-clean.
         timeoutHandle: setTimeout(() => {
-          void self.desktopFlows.finish(flowId, Err("Timed out waiting for OAuth callback"));
+          Effect.runFork(
+            self.desktopFlows.finishEffect(flowId, Err("Timed out waiting for OAuth callback"))
+          );
         }, DEFAULT_DESKTOP_TIMEOUT_MS),
       });
 
@@ -353,7 +355,7 @@ export class MuxGatewayOauthService {
         result = Err(`Xum Gateway OAuth error: ${callbackOrDone.error}`);
       }
 
-      yield* Effect.promise(() => self.desktopFlows.finish(flowId, result));
+      yield* self.desktopFlows.finishEffect(flowId, result);
     });
   }
 
 
@@ -292,6 +292,74 @@ describe("OAuthFlowManager", () => {
     });
   });
 
+  // -----------------------------------------------------------------------
+  // guaranteed cleanup (per-flow scope)
+  // -----------------------------------------------------------------------
+
+  describe("guaranteed cleanup", () => {
+    it("closes the server and clears the timeout even when the deferred resolve throws", async () => {
+      // Per-flow scope guarantee: each resource has an independent release, so
+      // a defect while settling the deferred cannot leak the loopback server
+      // or the registration timeout. (The pre-Effect implementation skipped
+      // the server close when resolve threw.)
+      let serverClosed = false;
+      const mockServer = {
+        close: (cb?: (err?: Error) => void) => {
+          serverClosed = true;
+          if (cb) cb();
+          return mockServer;
+        },
+      } as unknown as http.Server;
+
+      let timeoutFired = false;
+      const entry: OAuthFlowEntry = {
+        server: mockServer,
+        resultDeferred: {
+          promise: createDeferred<Result<void, string>>().promise,
+          resolve: () => {
+            throw new Error("resolve exploded");
+          },
+        },
+        timeoutHandle: setTimeout(() => {
+          timeoutFired = true;
+        }, 10),
+      };
+      manager.register("f1", entry);
+
+      // Must not reject despite the resolve defect.
+      await manager.finish("f1", Ok(undefined));
+
+      expect(manager.has("f1")).toBe(false);
+      expect(serverClosed).toBe(true);
+
+      await new Promise((resolve) => setTimeout(resolve, 25));
+      expect(timeoutFired).toBe(false);
+    });
+
+    it("closes the loopback server after a waitFor timeout even though waitFor already returned", async () => {
+      // The timeout-path cleanup is fire-and-forget (waitFor resolves without
+      // waiting for the server close); the detached release fiber must still
+      // complete after waitFor's own fiber has exited.
+      let serverClosed = false;
+      const mockServer = {
+        close: (cb?: (err?: Error) => void) => {
+          serverClosed = true;
+          if (cb) cb();
+          return mockServer;
+        },
+      } as unknown as http.Server;
+
+      manager.register("f1", createFlowEntry(mockServer));
+
+      const result = await manager.waitFor("f1", 10);
+      expect(result.success).toBe(false);
+      expect(manager.has("f1")).toBe(false);
+
+      await new Promise((resolve) => setTimeout(resolve, 25));
+      expect(serverClosed).toBe(true);
+    });
+  });
+
   // -----------------------------------------------------------------------
   // shutdownAll
   // -----------------------------------------------------------------------