chore(lint): enforce unnecessaryFailYieldableError

apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts

@@ -1511,12 +1511,10 @@ describe("ClaudeAdapterV2 attachments", () => {
                 Effect.gen(function* () {
                   if (failOpen) {
                     failOpen = false;
-                    return yield* Effect.fail(
-                      new ClaudeAdapterV2.ClaudeAgentSdkQueryRunnerError({
-                        method: "open",
-                        cause: "rejected open",
-                      }),
-                    );
+                    return yield* new ClaudeAdapterV2.ClaudeAgentSdkQueryRunnerError({
+                      method: "open",
+                      cause: "rejected open",
+                    });
                   }
                   const messages = yield* Queue.unbounded<SDKMessage>();
                   return {

apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts

@@ -7175,7 +7175,7 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
                 const terminationResults = yield* terminateTrackedTerminals(interruptTargets);
                 const failedTermination = terminationResults.find((result) => !result.success);
                 if (failedTermination !== undefined && !failedTermination.success) {
-                  return yield* Effect.fail(failedTermination.error);
+                  return yield* failedTermination.error;
                 }
                 yield* turnTerminalizationPermit.withPermits(1)(
                   Effect.gen(function* () {

apps/server/src/orchestration-v2/ThreadManagementService.ts

@@ -1195,7 +1195,7 @@ const make = Effect.gen(function* () {
         ),
       );
     }
-    if (failures[0] !== undefined) return yield* Effect.fail(failures[0]);
+    if (failures[0] !== undefined) return yield* failures[0];
   });
 
   return ThreadManagementService.of({

apps/server/src/provider/ProviderAuthService.test.ts

@@ -281,13 +281,11 @@ const makeHarness = Effect.fn("ProviderAuthService.test.makeHarness")(function*
               actions.push(`stop:${providerSessionId}`);
               yield* input.beforeStop ?? Effect.void;
               if (input.stopError) {
-                return yield* Effect.fail(
-                  new ProviderSessionManager.ProviderSessionReleaseError({
-                    providerSessionId,
-                    reason,
-                    cause: new Error("private process diagnostics"),
-                  }),
-                );
+                return yield* new ProviderSessionManager.ProviderSessionReleaseError({
+                  providerSessionId,
+                  reason,
+                  cause: new Error("private process diagnostics"),
+                });
               }
               released.push(providerSessionId);
               for (const [threadId, list] of sessions) {

apps/server/src/storageCleanup.ts

@@ -692,14 +692,12 @@ const make = Effect.gen(function* () {
       timeoutMs: 300_000,
     });
     if (result.exitCode !== 0)
-      return yield* Effect.fail(
-        new GitCommandError({
-          operation: "StorageCleanup.cleanupGit",
-          command,
-          cwd,
-          detail: result.stderr.trim().split(/\r?\n/)[0]?.slice(0, 1000) || "command failed",
-        }),
-      );
+      return yield* new GitCommandError({
+        operation: "StorageCleanup.cleanupGit",
+        command,
+        cwd,
+        detail: result.stderr.trim().split(/\r?\n/)[0]?.slice(0, 1000) || "command failed",
+      });
   });
 
   const cleanWorktrees = Effect.fn("StorageCleanup.cleanWorktrees")(function* (

apps/server/src/ws.ts

@@ -2430,29 +2430,23 @@ export const layerWsRpc = (
                 ) ?? projection.providerThreads.at(-1);
               const providerSessionId = providerThread?.providerSessionId ?? null;
               if (providerThread === undefined || providerSessionId === null) {
-                return yield* Effect.fail(
-                  new ProviderUploadFeedbackError({
-                    threadId: input.threadId,
-                    cause: "No provider session has run in this thread yet.",
-                  }),
-                );
+                return yield* new ProviderUploadFeedbackError({
+                  threadId: input.threadId,
+                  cause: "No provider session has run in this thread yet.",
+                });
               }
               const runtime = Option.getOrNull(yield* providerSessionsV2.get(providerSessionId));
               if (runtime === null) {
-                return yield* Effect.fail(
-                  new ProviderUploadFeedbackError({
-                    threadId: input.threadId,
-                    cause: "The provider session is no longer running. Send a message first.",
-                  }),
-                );
+                return yield* new ProviderUploadFeedbackError({
+                  threadId: input.threadId,
+                  cause: "The provider session is no longer running. Send a message first.",
+                });
               }
               if (runtime.uploadFeedback === undefined) {
-                return yield* Effect.fail(
-                  new ProviderUploadFeedbackError({
-                    threadId: input.threadId,
-                    cause: `Provider '${runtime.driver}' does not support feedback uploads.`,
-                  }),
-                );
+                return yield* new ProviderUploadFeedbackError({
+                  threadId: input.threadId,
+                  cause: `Provider '${runtime.driver}' does not support feedback uploads.`,
+                });
               }
               return yield* runtime.uploadFeedback({
                 providerThread,

packages/client-runtime/src/state/commandPermissions.ts

@@ -59,12 +59,10 @@ function makeCommandPermissions<R, E>(
             (scope) => Option.isNone(session) || !sessionGrantsScope(session.value, scope),
           );
           if (missing !== undefined)
-            return yield* Effect.fail(
-              new EnvironmentAuthorizationError({
-                ...authScopeRequiredResponse(missing),
-                message: `This connection requires ${missing}.`,
-              }),
-            );
+            return yield* new EnvironmentAuthorizationError({
+              ...authScopeRequiredResponse(missing),
+              message: `This connection requires ${missing}.`,
+            });
         }),
       );
     });

packages/provider-opencode/src/server/adapter.ts

@@ -1061,7 +1061,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
             return firstFailure ?? failures.find((failure) => failure !== undefined);
           });
           const failure = yield* visit(rootId, false);
-          if (failure) return yield* Effect.fail(failure);
+          if (failure) return yield* failure;
         }, Effect.timeout("15 seconds"));
 
         const updateProviderSession =

packages/source-control-github/src/server/gitHubGraphQlClient.ts

@@ -103,7 +103,7 @@ const refused = Effect.fn("gitHubGraphQlClient.refused")(function* (
 ) {
   const reason = error.reason;
   if (reason._tag !== "TransportError" && reason._tag !== "ResponseError") {
-    return yield* Effect.fail(error);
+    return yield* error;
   }
   const status = reason.status;
   if (reason._tag === "TransportError" && status === undefined) {

tsconfig.base.json

@@ -24,6 +24,7 @@
         "namespaceImportPackages": ["@effect/platform-node", "effect"],
         "effectFn": ["span", "inferred-span", "suggested-span"],
         "diagnosticSeverity": {
+          "unnecessaryFailYieldableError": "error",
           "preferSucceedSomeOrNone": "error",
           "effectSucceedWithVoid": "error",
           "provideLayerSucceedToProvideService": "error",