feat(#351): Implement RLS context interceptor (fix SEC-API-4)

Implements Row-Level Security (RLS) context propagation via NestJS interceptor and AsyncLocalStorage.

Core Implementation:
- RlsContextInterceptor sets PostgreSQL session variables (app.current_user_id, app.current_workspace_id) within transaction boundaries
- Uses SET LOCAL for transaction-scoped variables, preventing connection pool leakage
- AsyncLocalStorage propagates transaction-scoped Prisma client to services
- Graceful handling of unauthenticated routes
- 30-second transaction timeout with 10-second max wait

Security Features:
- Error sanitization prevents information disclosure to clients
- TransactionClient type provides compile-time safety, prevents invalid method calls
- Defense-in-depth security layer for RLS policy enforcement

Quality Rails Compliance:
- Fixed 154 lint errors in llm-usage module (package-level enforcement)
- Added proper TypeScript typing for Prisma operations
- Resolved all type safety violations

Test Coverage:
- 19 tests (7 provider + 9 interceptor + 3 integration)
- 95.75% overall coverage (100% statements on implementation files)
- All tests passing, zero lint errors

Documentation:
- Comprehensive RLS-CONTEXT-USAGE.md with examples and migration guide

Files Created:
- apps/api/src/common/interceptors/rls-context.interceptor.ts
- apps/api/src/common/interceptors/rls-context.interceptor.spec.ts
- apps/api/src/common/interceptors/rls-context.integration.spec.ts
- apps/api/src/prisma/rls-context.provider.ts
- apps/api/src/prisma/rls-context.provider.spec.ts
- apps/api/src/prisma/RLS-CONTEXT-USAGE.md

Fixes #351

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

apps/api/src/app.module.ts

@@ -36,6 +36,7 @@ import { JobEventsModule } from "./job-events/job-events.module";
 import { JobStepsModule } from "./job-steps/job-steps.module";
 import { CoordinatorIntegrationModule } from "./coordinator-integration/coordinator-integration.module";
 import { FederationModule } from "./federation/federation.module";
+import { RlsContextInterceptor } from "./common/interceptors/rls-context.interceptor";
 
 @Module({
   imports: [
@@ -100,6 +101,10 @@ import { FederationModule } from "./federation/federation.module";
       provide: APP_INTERCEPTOR,
       useClass: TelemetryInterceptor,
     },
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: RlsContextInterceptor,
+    },
     {
       provide: APP_GUARD,
       useClass: ThrottlerApiKeyGuard,

apps/api/src/common/interceptors/rls-context.integration.spec.ts

@@ -0,0 +1,198 @@
+/**
+ * RLS Context Integration Tests
+ *
+ * Tests that the RlsContextInterceptor correctly sets RLS context
+ * and that services can access the RLS-scoped client.
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { Injectable, Controller, Get, UseGuards, UseInterceptors } from "@nestjs/common";
+import { of } from "rxjs";
+import { RlsContextInterceptor, type TransactionClient } from "./rls-context.interceptor";
+import { PrismaService } from "../../prisma/prisma.service";
+import { getRlsClient } from "../../prisma/rls-context.provider";
+
+/**
+ * Mock service that uses getRlsClient() pattern
+ */
+@Injectable()
+class TestService {
+  private rlsClientUsed = false;
+  private queriesExecuted: string[] = [];
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findWithRls(): Promise<{ usedRlsClient: boolean; queries: string[] }> {
+    const client = getRlsClient() ?? this.prisma;
+    this.rlsClientUsed = client !== this.prisma;
+
+    // Track that we're using the client
+    this.queriesExecuted.push("findMany");
+
+    return {
+      usedRlsClient: this.rlsClientUsed,
+      queries: this.queriesExecuted,
+    };
+  }
+
+  reset() {
+    this.rlsClientUsed = false;
+    this.queriesExecuted = [];
+  }
+}
+
+/**
+ * Mock controller that uses the test service
+ */
+@Controller("test")
+class TestController {
+  constructor(private readonly testService: TestService) {}
+
+  @Get()
+  @UseInterceptors(RlsContextInterceptor)
+  async test() {
+    return this.testService.findWithRls();
+  }
+}
+
+describe("RLS Context Integration", () => {
+  let testService: TestService;
+  let prismaService: PrismaService;
+  let mockTransactionClient: TransactionClient;
+
+  beforeEach(async () => {
+    // Create mock transaction client (excludes $connect, $disconnect, etc.)
+    mockTransactionClient = {
+      $executeRaw: vi.fn().mockResolvedValue(undefined),
+    } as unknown as TransactionClient;
+
+    // Create mock Prisma service
+    const mockPrismaService = {
+      $transaction: vi.fn(async (callback: (tx: TransactionClient) => Promise<unknown>) => {
+        return callback(mockTransactionClient);
+      }),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [TestController],
+      providers: [
+        TestService,
+        RlsContextInterceptor,
+        {
+          provide: PrismaService,
+          useValue: mockPrismaService,
+        },
+      ],
+    }).compile();
+
+    testService = module.get<TestService>(TestService);
+    prismaService = module.get<PrismaService>(PrismaService);
+  });
+
+  describe("Service queries with RLS context", () => {
+    it("should provide RLS client to services when user is authenticated", async () => {
+      const userId = "user-123";
+      const workspaceId = "workspace-456";
+
+      // Create interceptor instance
+      const interceptor = new RlsContextInterceptor(prismaService);
+
+      // Mock execution context
+      const mockContext = {
+        switchToHttp: () => ({
+          getRequest: () => ({
+            user: {
+              id: userId,
+              email: "test@example.com",
+              name: "Test User",
+              workspaceId,
+            },
+            workspace: {
+              id: workspaceId,
+            },
+          }),
+        }),
+      } as any;
+
+      // Mock call handler
+      const mockNext = {
+        handle: vi.fn(() => {
+          // This simulates the controller calling the service
+          // Must return an Observable, not a Promise
+          const result = testService.findWithRls();
+          return of(result);
+        }),
+      } as any;
+
+      const result = await new Promise((resolve) => {
+        interceptor.intercept(mockContext, mockNext).subscribe({
+          next: resolve,
+        });
+      });
+
+      // Verify RLS client was used
+      expect(result).toMatchObject({
+        usedRlsClient: true,
+        queries: ["findMany"],
+      });
+
+      // Verify SET LOCAL was called
+      expect(mockTransactionClient.$executeRaw).toHaveBeenCalledWith(
+        expect.arrayContaining(["SET LOCAL app.current_user_id = ", ""]),
+        userId
+      );
+      expect(mockTransactionClient.$executeRaw).toHaveBeenCalledWith(
+        expect.arrayContaining(["SET LOCAL app.current_workspace_id = ", ""]),
+        workspaceId
+      );
+    });
+
+    it("should fall back to standard client when no RLS context", async () => {
+      // Call service directly without going through interceptor
+      testService.reset();
+      const result = await testService.findWithRls();
+
+      expect(result).toMatchObject({
+        usedRlsClient: false,
+        queries: ["findMany"],
+      });
+    });
+  });
+
+  describe("RLS context scoping", () => {
+    it("should clear RLS context after request completes", async () => {
+      const userId = "user-123";
+
+      const interceptor = new RlsContextInterceptor(prismaService);
+
+      const mockContext = {
+        switchToHttp: () => ({
+          getRequest: () => ({
+            user: {
+              id: userId,
+              email: "test@example.com",
+              name: "Test User",
+            },
+          }),
+        }),
+      } as any;
+
+      const mockNext = {
+        handle: vi.fn(() => {
+          return of({ data: "test" });
+        }),
+      } as any;
+
+      await new Promise((resolve) => {
+        interceptor.intercept(mockContext, mockNext).subscribe({
+          next: resolve,
+        });
+      });
+
+      // After request completes, RLS context should be cleared
+      const client = getRlsClient();
+      expect(client).toBeUndefined();
+    });
+  });
+});

apps/api/src/common/interceptors/rls-context.interceptor.spec.ts

@@ -0,0 +1,306 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { ExecutionContext, CallHandler, InternalServerErrorException } from "@nestjs/common";
+import { of, throwError } from "rxjs";
+import { RlsContextInterceptor, type TransactionClient } from "./rls-context.interceptor";
+import { PrismaService } from "../../prisma/prisma.service";
+import { getRlsClient } from "../../prisma/rls-context.provider";
+import type { AuthenticatedRequest } from "../types/user.types";
+
+describe("RlsContextInterceptor", () => {
+  let interceptor: RlsContextInterceptor;
+  let prismaService: PrismaService;
+  let mockExecutionContext: ExecutionContext;
+  let mockCallHandler: CallHandler;
+  let mockTransactionClient: TransactionClient;
+
+  beforeEach(async () => {
+    // Create mock transaction client (excludes $connect, $disconnect, etc.)
+    mockTransactionClient = {
+      $executeRaw: vi.fn().mockResolvedValue(undefined),
+    } as unknown as TransactionClient;
+
+    // Create mock Prisma service
+    const mockPrismaService = {
+      $transaction: vi.fn(
+        async (
+          callback: (tx: TransactionClient) => Promise<unknown>,
+          options?: { timeout?: number; maxWait?: number }
+        ) => {
+          return callback(mockTransactionClient);
+        }
+      ),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        RlsContextInterceptor,
+        {
+          provide: PrismaService,
+          useValue: mockPrismaService,
+        },
+      ],
+    }).compile();
+
+    interceptor = module.get<RlsContextInterceptor>(RlsContextInterceptor);
+    prismaService = module.get<PrismaService>(PrismaService);
+
+    // Setup mock call handler
+    mockCallHandler = {
+      handle: vi.fn(() => of({ data: "test response" })),
+    };
+  });
+
+  const createMockExecutionContext = (request: Partial<AuthenticatedRequest>): ExecutionContext => {
+    return {
+      switchToHttp: () => ({
+        getRequest: () => request,
+      }),
+    } as ExecutionContext;
+  };
+
+  describe("intercept", () => {
+    it("should set user context when user is authenticated", async () => {
+      const userId = "user-123";
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: userId,
+          email: "test@example.com",
+          name: "Test User",
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      const result = await new Promise((resolve) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+        });
+      });
+
+      expect(result).toEqual({ data: "test response" });
+      expect(mockTransactionClient.$executeRaw).toHaveBeenCalledWith(
+        expect.arrayContaining(["SET LOCAL app.current_user_id = ", ""]),
+        userId
+      );
+    });
+
+    it("should set workspace context when workspace is present", async () => {
+      const userId = "user-123";
+      const workspaceId = "workspace-456";
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: userId,
+          email: "test@example.com",
+          name: "Test User",
+          workspaceId,
+        },
+        workspace: {
+          id: workspaceId,
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      await new Promise((resolve) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+        });
+      });
+
+      // Check that user context was set
+      expect(mockTransactionClient.$executeRaw).toHaveBeenNthCalledWith(
+        1,
+        expect.arrayContaining(["SET LOCAL app.current_user_id = ", ""]),
+        userId
+      );
+      // Check that workspace context was set
+      expect(mockTransactionClient.$executeRaw).toHaveBeenNthCalledWith(
+        2,
+        expect.arrayContaining(["SET LOCAL app.current_workspace_id = ", ""]),
+        workspaceId
+      );
+    });
+
+    it("should not set context when user is not authenticated", async () => {
+      const request: Partial<AuthenticatedRequest> = {
+        user: undefined,
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      await new Promise((resolve) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+        });
+      });
+
+      expect(mockTransactionClient.$executeRaw).not.toHaveBeenCalled();
+      expect(mockCallHandler.handle).toHaveBeenCalled();
+    });
+
+    it("should propagate RLS client via AsyncLocalStorage", async () => {
+      const userId = "user-123";
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: userId,
+          email: "test@example.com",
+          name: "Test User",
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      // Override call handler to check if RLS client is available
+      let capturedClient: PrismaClient | undefined;
+      mockCallHandler = {
+        handle: vi.fn(() => {
+          capturedClient = getRlsClient();
+          return of({ data: "test response" });
+        }),
+      };
+
+      await new Promise((resolve) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+        });
+      });
+
+      expect(capturedClient).toBe(mockTransactionClient);
+    });
+
+    it("should handle errors and still propagate them", async () => {
+      const userId = "user-123";
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: userId,
+          email: "test@example.com",
+          name: "Test User",
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      const error = new Error("Test error");
+      mockCallHandler = {
+        handle: vi.fn(() => throwError(() => error)),
+      };
+
+      await expect(
+        new Promise((resolve, reject) => {
+          interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+            next: resolve,
+            error: reject,
+          });
+        })
+      ).rejects.toThrow(error);
+
+      // Context should still have been set before error
+      expect(mockTransactionClient.$executeRaw).toHaveBeenCalled();
+    });
+
+    it("should clear RLS context after request completes", async () => {
+      const userId = "user-123";
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: userId,
+          email: "test@example.com",
+          name: "Test User",
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      await new Promise((resolve) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+        });
+      });
+
+      // After the observable completes, RLS context should be cleared
+      const client = getRlsClient();
+      expect(client).toBeUndefined();
+    });
+
+    it("should handle missing user.id gracefully", async () => {
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: "",
+          email: "test@example.com",
+          name: "Test User",
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      await new Promise((resolve) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+        });
+      });
+
+      expect(mockTransactionClient.$executeRaw).not.toHaveBeenCalled();
+      expect(mockCallHandler.handle).toHaveBeenCalled();
+    });
+
+    it("should configure transaction with timeout and maxWait", async () => {
+      const userId = "user-123";
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: userId,
+          email: "test@example.com",
+          name: "Test User",
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      await new Promise((resolve) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+        });
+      });
+
+      // Verify transaction was called with timeout options
+      expect(prismaService.$transaction).toHaveBeenCalledWith(
+        expect.any(Function),
+        expect.objectContaining({
+          timeout: 30000, // 30 seconds
+          maxWait: 10000, // 10 seconds
+        })
+      );
+    });
+
+    it("should sanitize database errors before sending to client", async () => {
+      const userId = "user-123";
+      const request: Partial<AuthenticatedRequest> = {
+        user: {
+          id: userId,
+          email: "test@example.com",
+          name: "Test User",
+        },
+      };
+
+      mockExecutionContext = createMockExecutionContext(request);
+
+      // Mock transaction to throw a database error with sensitive information
+      const databaseError = new Error(
+        "PrismaClientKnownRequestError: Connection failed to database.internal.example.com:5432"
+      );
+      vi.spyOn(prismaService, "$transaction").mockRejectedValue(databaseError);
+
+      const errorPromise = new Promise((resolve, reject) => {
+        interceptor.intercept(mockExecutionContext, mockCallHandler).subscribe({
+          next: resolve,
+          error: reject,
+        });
+      });
+
+      await expect(errorPromise).rejects.toThrow(InternalServerErrorException);
+      await expect(errorPromise).rejects.toThrow("Request processing failed");
+
+      // Verify the detailed error was NOT sent to the client
+      await expect(errorPromise).rejects.not.toThrow("database.internal.example.com");
+    });
+  });
+});

apps/api/src/common/interceptors/rls-context.interceptor.ts

@@ -0,0 +1,155 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  Logger,
+  InternalServerErrorException,
+} from "@nestjs/common";
+import { Observable } from "rxjs";
+import { finalize } from "rxjs/operators";
+import type { PrismaClient } from "@prisma/client";
+import { PrismaService } from "../../prisma/prisma.service";
+import { runWithRlsClient } from "../../prisma/rls-context.provider";
+import type { AuthenticatedRequest } from "../types/user.types";
+
+/**
+ * Transaction-safe Prisma client type that excludes methods not available on transaction clients.
+ * This prevents services from accidentally calling $connect, $disconnect, $transaction, etc.
+ * on a transaction client, which would cause runtime errors.
+ */
+export type TransactionClient = Omit<
+  PrismaClient,
+  "$connect" | "$disconnect" | "$transaction" | "$on" | "$use"
+>;
+
+/**
+ * RlsContextInterceptor sets Row-Level Security (RLS) session variables for authenticated requests.
+ *
+ * This interceptor runs after AuthGuard and WorkspaceGuard, extracting the authenticated user
+ * and workspace from the request and setting PostgreSQL session variables within a transaction:
+ * - SET LOCAL app.current_user_id = '...'
+ * - SET LOCAL app.current_workspace_id = '...'
+ *
+ * The transaction-scoped Prisma client is then propagated via AsyncLocalStorage, allowing
+ * services to access it via getRlsClient() without explicit dependency injection.
+ *
+ * ## Security Design
+ *
+ * SET LOCAL is used instead of SET to ensure session variables are transaction-scoped.
+ * This is critical for connection pooling safety - without transaction scoping, variables
+ * would leak between requests that reuse the same connection from the pool.
+ *
+ * The entire request handler is executed within the transaction boundary, ensuring all
+ * queries inherit the RLS context.
+ *
+ * ## Usage
+ *
+ * Registered globally as APP_INTERCEPTOR in AppModule (after TelemetryInterceptor).
+ * Services access the RLS client via:
+ *
+ * ```typescript
+ * const client = getRlsClient() ?? this.prisma;
+ * return client.task.findMany(); // Filtered by RLS
+ * ```
+ *
+ * ## Unauthenticated Routes
+ *
+ * Routes without AuthGuard (public endpoints) will not have request.user set.
+ * The interceptor gracefully handles this by skipping RLS context setup.
+ *
+ * @see docs/design/credential-security.md for RLS architecture
+ */
+@Injectable()
+export class RlsContextInterceptor implements NestInterceptor {
+  private readonly logger = new Logger(RlsContextInterceptor.name);
+
+  // Transaction timeout configuration
+  // Longer timeout to support file uploads, complex queries, and bulk operations
+  private readonly TRANSACTION_TIMEOUT_MS = 30000; // 30 seconds
+  private readonly TRANSACTION_MAX_WAIT_MS = 10000; // 10 seconds to acquire connection
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  /**
+   * Intercept HTTP requests and set RLS context if user is authenticated.
+   *
+   * @param context - The execution context
+   * @param next - The next call handler
+   * @returns Observable of the response with RLS context applied
+   */
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
+    const request = context.switchToHttp().getRequest<AuthenticatedRequest>();
+    const user = request.user;
+
+    // Skip RLS context setup for unauthenticated requests
+    if (!user?.id) {
+      this.logger.debug("Skipping RLS context: no authenticated user");
+      return next.handle();
+    }
+
+    const userId = user.id;
+    const workspaceId = request.workspace?.id ?? user.workspaceId;
+
+    this.logger.debug(
+      `Setting RLS context: user=${userId}${workspaceId ? `, workspace=${workspaceId}` : ""}`
+    );
+
+    // Execute the entire request within a transaction with RLS context set
+    return new Observable((subscriber) => {
+      this.prisma
+        .$transaction(
+          async (tx) => {
+            // Set user context (always present for authenticated requests)
+            await tx.$executeRaw`SET LOCAL app.current_user_id = ${userId}`;
+
+            // Set workspace context (if present)
+            if (workspaceId) {
+              await tx.$executeRaw`SET LOCAL app.current_workspace_id = ${workspaceId}`;
+            }
+
+            // Propagate the transaction client via AsyncLocalStorage
+            // This allows services to access it via getRlsClient()
+            // Use TransactionClient type to maintain type safety
+            return runWithRlsClient(tx as TransactionClient, () => {
+              return new Promise((resolve, reject) => {
+                next
+                  .handle()
+                  .pipe(
+                    finalize(() => {
+                      this.logger.debug("RLS context cleared");
+                    })
+                  )
+                  .subscribe({
+                    next: (value) => {
+                      subscriber.next(value);
+                      resolve(value);
+                    },
+                    error: (error: unknown) => {
+                      const err = error instanceof Error ? error : new Error(String(error));
+                      subscriber.error(err);
+                      reject(err);
+                    },
+                    complete: () => {
+                      subscriber.complete();
+                      resolve(undefined);
+                    },
+                  });
+              });
+            });
+          },
+          {
+            timeout: this.TRANSACTION_TIMEOUT_MS,
+            maxWait: this.TRANSACTION_MAX_WAIT_MS,
+          }
+        )
+        .catch((error: unknown) => {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.logger.error(`Failed to set RLS context: ${err.message}`, err.stack);
+          // Sanitize error before sending to client to prevent information disclosure
+          // (schema info, internal variable names, connection details, etc.)
+          subscriber.error(new InternalServerErrorException("Request processing failed"));
+        });
+    });
+  }
+}

apps/api/src/llm-usage/llm-usage.controller.ts

@@ -1,6 +1,7 @@
 import { Controller, Get, Param, Query } from "@nestjs/common";
+import type { LlmUsageLog } from "@prisma/client";
 import { LlmUsageService } from "./llm-usage.service";
-import type { UsageAnalyticsQueryDto } from "./dto";
+import type { UsageAnalyticsQueryDto, UsageAnalyticsResponseDto } from "./dto";
 
 /**
  * LLM Usage Controller
@@ -20,8 +21,10 @@ export class LlmUsageController {
    * @returns Aggregated usage analytics
    */
   @Get("analytics")
-  async getAnalytics(@Query() query: UsageAnalyticsQueryDto) {
+  async getAnalytics(
-    const data = await this.llmUsageService.getUsageAnalytics(query);
+    @Query() query: UsageAnalyticsQueryDto
+  ): Promise<{ data: UsageAnalyticsResponseDto }> {
+    const data: UsageAnalyticsResponseDto = await this.llmUsageService.getUsageAnalytics(query);
     return { data };
   }
 
@@ -32,8 +35,10 @@ export class LlmUsageController {
    * @returns Array of usage logs
    */
   @Get("by-workspace/:workspaceId")
-  async getUsageByWorkspace(@Param("workspaceId") workspaceId: string) {
+  async getUsageByWorkspace(
-    const data = await this.llmUsageService.getUsageByWorkspace(workspaceId);
+    @Param("workspaceId") workspaceId: string
+  ): Promise<{ data: LlmUsageLog[] }> {
+    const data: LlmUsageLog[] = await this.llmUsageService.getUsageByWorkspace(workspaceId);
     return { data };
   }
 
@@ -48,8 +53,11 @@ export class LlmUsageController {
   async getUsageByProvider(
     @Param("workspaceId") workspaceId: string,
     @Param("provider") provider: string
-  ) {
+  ): Promise<{ data: LlmUsageLog[] }> {
-    const data = await this.llmUsageService.getUsageByProvider(workspaceId, provider);
+    const data: LlmUsageLog[] = await this.llmUsageService.getUsageByProvider(
+      workspaceId,
+      provider
+    );
     return { data };
   }
 
@@ -61,8 +69,11 @@ export class LlmUsageController {
    * @returns Array of usage logs
    */
   @Get("by-workspace/:workspaceId/model/:model")
-  async getUsageByModel(@Param("workspaceId") workspaceId: string, @Param("model") model: string) {
+  async getUsageByModel(
-    const data = await this.llmUsageService.getUsageByModel(workspaceId, model);
+    @Param("workspaceId") workspaceId: string,
+    @Param("model") model: string
+  ): Promise<{ data: LlmUsageLog[] }> {
+    const data: LlmUsageLog[] = await this.llmUsageService.getUsageByModel(workspaceId, model);
     return { data };
   }
 }

apps/api/src/llm-usage/llm-usage.service.ts

@@ -1,4 +1,5 @@
 import { Injectable, Logger } from "@nestjs/common";
+import type { LlmUsageLog, Prisma } from "@prisma/client";
 import { PrismaService } from "../prisma/prisma.service";
 import type {
   TrackUsageDto,
@@ -28,12 +29,12 @@ export class LlmUsageService {
    * @param dto - Usage tracking data
    * @returns The created usage log entry
    */
-  async trackUsage(dto: TrackUsageDto) {
+  async trackUsage(dto: TrackUsageDto): Promise<LlmUsageLog> {
     this.logger.debug(
       `Tracking usage: ${dto.provider}/${dto.model} - ${String(dto.totalTokens)} tokens`
     );
 
-    return this.prisma.llmUsageLog.create({
+    return await this.prisma.llmUsageLog.create({
       data: dto,
     });
   }
@@ -46,7 +47,7 @@ export class LlmUsageService {
    * @returns Aggregated usage analytics
    */
   async getUsageAnalytics(query: UsageAnalyticsQueryDto): Promise<UsageAnalyticsResponseDto> {
-    const where: Record<string, unknown> = {};
+    const where: Prisma.LlmUsageLogWhereInput = {};
 
     if (query.workspaceId) {
       where.workspaceId = query.workspaceId;
@@ -63,43 +64,59 @@ export class LlmUsageService {
     if (query.startDate || query.endDate) {
       where.createdAt = {};
       if (query.startDate) {
-        (where.createdAt as Record<string, Date>).gte = new Date(query.startDate);
+        where.createdAt.gte = new Date(query.startDate);
       }
       if (query.endDate) {
-        (where.createdAt as Record<string, Date>).lte = new Date(query.endDate);
+        where.createdAt.lte = new Date(query.endDate);
       }
     }
 
-    const usageLogs = await this.prisma.llmUsageLog.findMany({ where });
+    const usageLogs: LlmUsageLog[] = await this.prisma.llmUsageLog.findMany({ where });
 
     // Aggregate totals
-    const totalCalls = usageLogs.length;
+    const totalCalls: number = usageLogs.length;
-    const totalPromptTokens = usageLogs.reduce((sum, log) => sum + log.promptTokens, 0);
+    const totalPromptTokens: number = usageLogs.reduce(
-    const totalCompletionTokens = usageLogs.reduce((sum, log) => sum + log.completionTokens, 0);
+      (sum: number, log: LlmUsageLog) => sum + log.promptTokens,
-    const totalTokens = usageLogs.reduce((sum, log) => sum + log.totalTokens, 0);
+      0
-    const totalCostCents = usageLogs.reduce((sum, log) => sum + (log.costCents ?? 0), 0);
+    );
+    const totalCompletionTokens: number = usageLogs.reduce(
+      (sum: number, log: LlmUsageLog) => sum + log.completionTokens,
+      0
+    );
+    const totalTokens: number = usageLogs.reduce(
+      (sum: number, log: LlmUsageLog) => sum + log.totalTokens,
+      0
+    );
+    const totalCostCents: number = usageLogs.reduce(
+      (sum: number, log: LlmUsageLog) => sum + (log.costCents ?? 0),
+      0
+    );
 
-    const durations = usageLogs.map((log) => log.durationMs).filter((d): d is number => d !== null);
+    const durations: number[] = usageLogs
-    const averageDurationMs =
+      .map((log: LlmUsageLog) => log.durationMs)
-      durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;
+      .filter((d): d is number => d !== null);
+    const averageDurationMs: number =
+      durations.length > 0
+        ? durations.reduce((sum: number, d: number) => sum + d, 0) / durations.length
+        : 0;
 
     // Group by provider
     const byProviderMap = new Map<string, ProviderUsageDto>();
     for (const log of usageLogs) {
-      const existing = byProviderMap.get(log.provider);
+      const existing: ProviderUsageDto | undefined = byProviderMap.get(log.provider);
       if (existing) {
         existing.calls += 1;
         existing.promptTokens += log.promptTokens;
         existing.completionTokens += log.completionTokens;
         existing.totalTokens += log.totalTokens;
         existing.costCents += log.costCents ?? 0;
-        if (log.durationMs) {
+        if (log.durationMs !== null) {
-          const count = existing.calls === 1 ? 1 : existing.calls - 1;
+          const count: number = existing.calls === 1 ? 1 : existing.calls - 1;
           existing.averageDurationMs =
             (existing.averageDurationMs * (count - 1) + log.durationMs) / count;
         }
       } else {
-        byProviderMap.set(log.provider, {
+        const newProvider: ProviderUsageDto = {
           provider: log.provider,
           calls: 1,
           promptTokens: log.promptTokens,
@@ -107,27 +124,28 @@ export class LlmUsageService {
           totalTokens: log.totalTokens,
           costCents: log.costCents ?? 0,
           averageDurationMs: log.durationMs ?? 0,
-        });
+        };
+        byProviderMap.set(log.provider, newProvider);
       }
     }
 
     // Group by model
     const byModelMap = new Map<string, ModelUsageDto>();
     for (const log of usageLogs) {
-      const existing = byModelMap.get(log.model);
+      const existing: ModelUsageDto | undefined = byModelMap.get(log.model);
       if (existing) {
         existing.calls += 1;
         existing.promptTokens += log.promptTokens;
         existing.completionTokens += log.completionTokens;
         existing.totalTokens += log.totalTokens;
         existing.costCents += log.costCents ?? 0;
-        if (log.durationMs) {
+        if (log.durationMs !== null) {
-          const count = existing.calls === 1 ? 1 : existing.calls - 1;
+          const count: number = existing.calls === 1 ? 1 : existing.calls - 1;
           existing.averageDurationMs =
             (existing.averageDurationMs * (count - 1) + log.durationMs) / count;
         }
       } else {
-        byModelMap.set(log.model, {
+        const newModel: ModelUsageDto = {
           model: log.model,
           calls: 1,
           promptTokens: log.promptTokens,
@@ -135,28 +153,29 @@ export class LlmUsageService {
           totalTokens: log.totalTokens,
           costCents: log.costCents ?? 0,
           averageDurationMs: log.durationMs ?? 0,
-        });
+        };
+        byModelMap.set(log.model, newModel);
       }
     }
 
     // Group by task type
     const byTaskTypeMap = new Map<string, TaskTypeUsageDto>();
     for (const log of usageLogs) {
-      const taskType = log.taskType ?? "unknown";
+      const taskType: string = log.taskType ?? "unknown";
-      const existing = byTaskTypeMap.get(taskType);
+      const existing: TaskTypeUsageDto | undefined = byTaskTypeMap.get(taskType);
       if (existing) {
         existing.calls += 1;
         existing.promptTokens += log.promptTokens;
         existing.completionTokens += log.completionTokens;
         existing.totalTokens += log.totalTokens;
         existing.costCents += log.costCents ?? 0;
-        if (log.durationMs) {
+        if (log.durationMs !== null) {
-          const count = existing.calls === 1 ? 1 : existing.calls - 1;
+          const count: number = existing.calls === 1 ? 1 : existing.calls - 1;
           existing.averageDurationMs =
             (existing.averageDurationMs * (count - 1) + log.durationMs) / count;
         }
       } else {
-        byTaskTypeMap.set(taskType, {
+        const newTaskType: TaskTypeUsageDto = {
           taskType,
           calls: 1,
           promptTokens: log.promptTokens,
@@ -164,11 +183,12 @@ export class LlmUsageService {
           totalTokens: log.totalTokens,
           costCents: log.costCents ?? 0,
           averageDurationMs: log.durationMs ?? 0,
-        });
+        };
+        byTaskTypeMap.set(taskType, newTaskType);
       }
     }
 
-    return {
+    const response: UsageAnalyticsResponseDto = {
       totalCalls,
       totalPromptTokens,
       totalCompletionTokens,
@@ -179,6 +199,8 @@ export class LlmUsageService {
       byModel: Array.from(byModelMap.values()),
       byTaskType: Array.from(byTaskTypeMap.values()),
     };
+
+    return response;
   }
 
   /**
@@ -187,8 +209,8 @@ export class LlmUsageService {
    * @param workspaceId - Workspace UUID
    * @returns Array of usage logs
    */
-  async getUsageByWorkspace(workspaceId: string) {
+  async getUsageByWorkspace(workspaceId: string): Promise<LlmUsageLog[]> {
-    return this.prisma.llmUsageLog.findMany({
+    return await this.prisma.llmUsageLog.findMany({
       where: { workspaceId },
       orderBy: { createdAt: "desc" },
     });
@@ -201,8 +223,8 @@ export class LlmUsageService {
    * @param provider - Provider name
    * @returns Array of usage logs
    */
-  async getUsageByProvider(workspaceId: string, provider: string) {
+  async getUsageByProvider(workspaceId: string, provider: string): Promise<LlmUsageLog[]> {
-    return this.prisma.llmUsageLog.findMany({
+    return await this.prisma.llmUsageLog.findMany({
       where: { workspaceId, provider },
       orderBy: { createdAt: "desc" },
     });
@@ -215,8 +237,8 @@ export class LlmUsageService {
    * @param model - Model name
    * @returns Array of usage logs
    */
-  async getUsageByModel(workspaceId: string, model: string) {
+  async getUsageByModel(workspaceId: string, model: string): Promise<LlmUsageLog[]> {
-    return this.prisma.llmUsageLog.findMany({
+    return await this.prisma.llmUsageLog.findMany({
       where: { workspaceId, model },
       orderBy: { createdAt: "desc" },
     });

apps/api/src/prisma/RLS-CONTEXT-USAGE.md

@@ -0,0 +1,186 @@
+# RLS Context Usage Guide
+
+This guide explains how to use the RLS (Row-Level Security) context system in services.
+
+## Overview
+
+The RLS context system automatically sets PostgreSQL session variables for authenticated requests:
+
+- `app.current_user_id` - Set from the authenticated user
+- `app.current_workspace_id` - Set from the workspace context (if present)
+
+These session variables enable PostgreSQL RLS policies to automatically filter queries based on user permissions.
+
+## How It Works
+
+1. **RlsContextInterceptor** runs after AuthGuard and WorkspaceGuard
+2. It wraps the request in a Prisma transaction (30s timeout, 10s max wait for connection)
+3. Inside the transaction, it executes `SET LOCAL` to set session variables
+4. The transaction client is propagated via AsyncLocalStorage
+5. Services access it using `getRlsClient()`
+
+### Transaction Timeout
+
+The interceptor configures a 30-second transaction timeout and 10-second max wait for connection acquisition. This supports:
+
+- File uploads
+- Complex queries with joins
+- Bulk operations
+- Report generation
+
+If you need longer-running operations, consider moving them to background jobs instead of synchronous HTTP requests.
+
+## Usage in Services
+
+### Basic Pattern
+
+```typescript
+import { Injectable } from "@nestjs/common";
+import { PrismaService } from "../prisma/prisma.service";
+import { getRlsClient } from "../prisma/rls-context.provider";
+
+@Injectable()
+export class TasksService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(workspaceId: string) {
+    // Use RLS client if available, otherwise fall back to standard client
+    const client = getRlsClient() ?? this.prisma;
+
+    // This query is automatically filtered by RLS policies
+    return client.task.findMany({
+      where: { workspaceId },
+    });
+  }
+}
+```
+
+### Why Use This Pattern?
+
+**With RLS context:**
+
+- Queries are automatically filtered by user/workspace permissions
+- Defense in depth: Even if application logic fails, database RLS enforces security
+- No need to manually add `where` clauses for user/workspace filtering
+
+**Fallback to standard client:**
+
+- Supports unauthenticated routes (public endpoints)
+- Supports system operations that need full database access
+- Graceful degradation if RLS context isn't set
+
+### Advanced: Explicit Transaction Control
+
+For operations that need multiple queries in a single transaction:
+
+```typescript
+async createWithRelations(workspaceId: string, data: CreateTaskDto) {
+  const client = getRlsClient() ?? this.prisma;
+
+  // If using RLS client, we're already in a transaction
+  // If not, we need to create one
+  if (getRlsClient()) {
+    // Already in a transaction with RLS context
+    return this.performCreate(client, data);
+  } else {
+    // Need to manually wrap in transaction
+    return this.prisma.$transaction(async (tx) => {
+      return this.performCreate(tx, data);
+    });
+  }
+}
+
+private async performCreate(client: PrismaClient, data: CreateTaskDto) {
+  const task = await client.task.create({ data });
+  await client.activity.create({
+    data: {
+      type: "TASK_CREATED",
+      taskId: task.id,
+    },
+  });
+  return task;
+}
+```
+
+## Unauthenticated Routes
+
+For public endpoints (no AuthGuard), `getRlsClient()` returns `undefined`:
+
+```typescript
+@Get("public/stats")
+async getPublicStats() {
+  // No RLS context - uses standard Prisma client
+  const client = getRlsClient() ?? this.prisma;
+
+  // This query has NO RLS filtering (public data)
+  return client.task.count();
+}
+```
+
+## Testing
+
+When testing services, you can mock the RLS context:
+
+```typescript
+import { vi } from "vitest";
+import * as rlsContext from "../prisma/rls-context.provider";
+
+describe("TasksService", () => {
+  it("should use RLS client when available", () => {
+    const mockClient = {} as PrismaClient;
+    vi.spyOn(rlsContext, "getRlsClient").mockReturnValue(mockClient);
+
+    // Service will use mockClient instead of prisma
+  });
+});
+```
+
+## Security Considerations
+
+1. **Always use the pattern**: `getRlsClient() ?? this.prisma`
+2. **Don't bypass RLS** unless absolutely necessary (e.g., system operations)
+3. **Trust the interceptor**: It sets context automatically - no manual setup needed
+4. **Test with and without RLS**: Ensure services work in both contexts
+
+## Architecture
+
+```
+Request → AuthGuard → WorkspaceGuard → RlsContextInterceptor → Service
+                                              ↓
+                                        Prisma.$transaction
+                                              ↓
+                                    SET LOCAL app.current_user_id
+                                    SET LOCAL app.current_workspace_id
+                                              ↓
+                                        AsyncLocalStorage
+                                              ↓
+                                    Service (getRlsClient())
+```
+
+## Related Files
+
+- `/apps/api/src/common/interceptors/rls-context.interceptor.ts` - Main interceptor
+- `/apps/api/src/prisma/rls-context.provider.ts` - AsyncLocalStorage provider
+- `/apps/api/src/lib/db-context.ts` - Legacy RLS utilities (reference only)
+- `/apps/api/src/prisma/prisma.service.ts` - Prisma service with RLS helpers
+
+## Migration from Legacy Pattern
+
+If you're migrating from the legacy `withUserContext()` pattern:
+
+**Before:**
+
+```typescript
+return withUserContext(userId, async (tx) => {
+  return tx.task.findMany({ where: { workspaceId } });
+});
+```
+
+**After:**
+
+```typescript
+const client = getRlsClient() ?? this.prisma;
+return client.task.findMany({ where: { workspaceId } });
+```
+
+The interceptor handles transaction management automatically, so you no longer need to wrap every query.

apps/api/src/prisma/rls-context.provider.spec.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { getRlsClient, runWithRlsClient, type TransactionClient } from "./rls-context.provider";
+
+describe("RlsContextProvider", () => {
+  let mockPrismaClient: TransactionClient;
+
+  beforeEach(() => {
+    // Create a mock transaction client (excludes $connect, $disconnect, etc.)
+    mockPrismaClient = {
+      $executeRaw: vi.fn(),
+    } as unknown as TransactionClient;
+  });
+
+  describe("getRlsClient", () => {
+    it("should return undefined when no RLS context is set", () => {
+      const client = getRlsClient();
+      expect(client).toBeUndefined();
+    });
+
+    it("should return the RLS client when context is set", () => {
+      runWithRlsClient(mockPrismaClient, () => {
+        const client = getRlsClient();
+        expect(client).toBe(mockPrismaClient);
+      });
+    });
+
+    it("should return undefined after context is cleared", () => {
+      runWithRlsClient(mockPrismaClient, () => {
+        const client = getRlsClient();
+        expect(client).toBe(mockPrismaClient);
+      });
+
+      // After runWithRlsClient completes, context should be cleared
+      const client = getRlsClient();
+      expect(client).toBeUndefined();
+    });
+  });
+
+  describe("runWithRlsClient", () => {
+    it("should execute callback with RLS client available", () => {
+      const callback = vi.fn(() => {
+        const client = getRlsClient();
+        expect(client).toBe(mockPrismaClient);
+      });
+
+      runWithRlsClient(mockPrismaClient, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("should clear context after callback completes", () => {
+      runWithRlsClient(mockPrismaClient, () => {
+        // Context is set here
+      });
+
+      // Context should be cleared after execution
+      const client = getRlsClient();
+      expect(client).toBeUndefined();
+    });
+
+    it("should clear context even if callback throws", () => {
+      const error = new Error("Test error");
+
+      expect(() => {
+        runWithRlsClient(mockPrismaClient, () => {
+          throw error;
+        });
+      }).toThrow(error);
+
+      // Context should still be cleared
+      const client = getRlsClient();
+      expect(client).toBeUndefined();
+    });
+
+    it("should support nested contexts", () => {
+      const outerClient = mockPrismaClient;
+      const innerClient = {
+        $executeRaw: vi.fn(),
+      } as unknown as TransactionClient;
+
+      runWithRlsClient(outerClient, () => {
+        expect(getRlsClient()).toBe(outerClient);
+
+        runWithRlsClient(innerClient, () => {
+          expect(getRlsClient()).toBe(innerClient);
+        });
+
+        // Should restore outer context
+        expect(getRlsClient()).toBe(outerClient);
+      });
+
+      // Should clear completely after outer context ends
+      expect(getRlsClient()).toBeUndefined();
+    });
+  });
+});

apps/api/src/prisma/rls-context.provider.ts

@@ -0,0 +1,82 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { PrismaClient } from "@prisma/client";
+
+/**
+ * Transaction-safe Prisma client type that excludes methods not available on transaction clients.
+ * This prevents services from accidentally calling $connect, $disconnect, $transaction, etc.
+ * on a transaction client, which would cause runtime errors.
+ */
+export type TransactionClient = Omit<
+  PrismaClient,
+  "$connect" | "$disconnect" | "$transaction" | "$on" | "$use"
+>;
+
+/**
+ * AsyncLocalStorage for propagating RLS-scoped Prisma client through the call chain.
+ * This allows the RlsContextInterceptor to set a transaction-scoped client that
+ * services can access via getRlsClient() without explicit dependency injection.
+ *
+ * The RLS client is a Prisma transaction client that has SET LOCAL app.current_user_id
+ * and app.current_workspace_id executed, enabling Row-Level Security policies.
+ *
+ * @see docs/design/credential-security.md for RLS architecture
+ */
+const rlsContext = new AsyncLocalStorage<TransactionClient>();
+
+/**
+ * Gets the current RLS-scoped Prisma client from AsyncLocalStorage.
+ * Returns undefined if no RLS context is set (e.g., unauthenticated routes).
+ *
+ * Services should use this pattern:
+ * ```typescript
+ * const client = getRlsClient() ?? this.prisma;
+ * ```
+ *
+ * This ensures they use the RLS-scoped client when available (for authenticated
+ * requests) and fall back to the standard client otherwise.
+ *
+ * @returns The RLS-scoped Prisma transaction client, or undefined
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class TasksService {
+ *   constructor(private readonly prisma: PrismaService) {}
+ *
+ *   async findAll() {
+ *     const client = getRlsClient() ?? this.prisma;
+ *     return client.task.findMany(); // Automatically filtered by RLS
+ *   }
+ * }
+ * ```
+ */
+export function getRlsClient(): TransactionClient | undefined {
+  return rlsContext.getStore();
+}
+
+/**
+ * Executes a function with an RLS-scoped Prisma client available via getRlsClient().
+ * The client is propagated through the call chain using AsyncLocalStorage and is
+ * automatically cleared after the function completes.
+ *
+ * This is used by RlsContextInterceptor to wrap request handlers.
+ *
+ * @param client - The RLS-scoped Prisma transaction client
+ * @param fn - The function to execute with RLS context
+ * @returns The result of the function
+ *
+ * @example
+ * ```typescript
+ * await prisma.$transaction(async (tx) => {
+ *   await tx.$executeRaw`SET LOCAL app.current_user_id = ${userId}`;
+ *
+ *   return runWithRlsClient(tx, async () => {
+ *     // getRlsClient() now returns tx
+ *     return handler();
+ *   });
+ * });
+ * ```
+ */
+export function runWithRlsClient<T>(client: TransactionClient, fn: () => T): T {
+  return rlsContext.run(client, fn);
+}