diff --git a/services/mana-auth/src/index.ts b/services/mana-auth/src/index.ts
index 0f6d1e325..0ab14b7c7 100644
--- a/services/mana-auth/src/index.ts
+++ b/services/mana-auth/src/index.ts
@@ -3,15 +3,6 @@
  *
  * Hono + Bun runtime. Replaces NestJS-based mana-core-auth.
  * Uses Better Auth natively (fetch-based handler, no Express conversion).
- *
- * Better Auth handles:
- * - Email/password auth with verification
- * - JWT tokens (EdDSA via JWKS)
- * - Sessions with cross-domain SSO
- * - Organizations (B2B multi-tenant)
- * - OIDC Provider (Matrix/Synapse SSO)
- * - Two-factor authentication (TOTP)
- * - Magic links (passwordless)
  */
 
 import { Hono } from 'hono';
@@ -23,6 +14,12 @@ import { errorHandler } from './middleware/error-handler';
 import { jwtAuth } from './middleware/jwt-auth';
 import { serviceAuth } from './middleware/service-auth';
 import { initializeEmail } from './email/send';
+import { SecurityEventsService, AccountLockoutService } from './services/security';
+import { ApiKeysService } from './services/api-keys';
+import { createAuthRoutes } from './routes/auth';
+import { createGuildRoutes } from './routes/guilds';
+import { createApiKeyRoutes, createApiKeyValidationRoute } from './routes/api-keys';
+import { createMeRoutes } from './routes/me';
 
 // ─── Bootstrap ──────────────────────────────────────────────
 
@@ -30,16 +27,17 @@ const config = loadConfig();
 const db = getDb(config.databaseUrl);
 const auth = createBetterAuth(config.databaseUrl);
 
-// Initialize email transport
+// Initialize services
 initializeEmail(config.smtp);
+const security = new SecurityEventsService(db);
+const lockout = new AccountLockoutService(db);
+const apiKeysService = new ApiKeysService(db);
 
 // ─── App ────────────────────────────────────────────────────
 
 const app = new Hono();
 
 app.onError(errorHandler);
-
-// CORS — must match Better Auth trustedOrigins
 app.use(
 	'*',
 	cors({
@@ -57,150 +55,64 @@ app.get('/health', (c) =>
 );
 
 // ─── Better Auth Native Handler ─────────────────────────────
-// Better Auth's handler is fetch-based — Hono is fetch-based.
-// No Express↔Fetch conversion needed! Just forward the request.
 
-app.all('/api/auth/*', async (c) => {
-	const response = await auth.handler(c.req.raw);
-	return response;
-});
-
-// OIDC Discovery (must be at root)
-app.get('/.well-known/openid-configuration', async (c) => {
-	const response = await auth.handler(c.req.raw);
-	return response;
-});
+app.all('/api/auth/*', async (c) => auth.handler(c.req.raw));
+app.get('/.well-known/openid-configuration', async (c) => auth.handler(c.req.raw));
 
 // ─── Custom Auth Endpoints ──────────────────────────────────
-// Wrapper routes that add business logic around Better Auth
 
-app.post('/api/v1/auth/register', async (c) => {
-	const body = await c.req.json();
+app.route('/api/v1/auth', createAuthRoutes(auth, config, security, lockout));
 
-	// Store source app URL for email verification redirect
-	if (body.sourceAppUrl && body.email) {
-		const { sourceAppStore } = await import('./auth/stores');
-		sourceAppStore.set(body.email, body.sourceAppUrl);
-	}
+// ─── Guilds ─────────────────────────────────────────────────
 
-	// Forward to Better Auth sign-up
-	const signUpUrl = new URL('/api/auth/sign-up/email', config.baseUrl);
-	const response = await auth.handler(
-		new Request(signUpUrl, {
-			method: 'POST',
-			headers: c.req.raw.headers,
-			body: JSON.stringify({
-				email: body.email,
-				password: body.password,
-				name: body.name || body.email.split('@')[0],
-			}),
-		})
-	);
+app.use('/api/v1/gilden/*', jwtAuth(config.baseUrl));
+app.route('/api/v1/gilden', createGuildRoutes(auth, config));
 
-	if (response.ok) {
-		// Initialize credit balance via mana-credits (fire-and-forget)
-		const result = await response.json();
-		if (result?.user?.id) {
-			fetch(`${config.manaCreditsUrl}/api/v1/internal/credits/init`, {
-				method: 'POST',
-				headers: { 'Content-Type': 'application/json', 'X-Service-Key': config.serviceKey },
-				body: JSON.stringify({ userId: result.user.id }),
-			}).catch(() => {});
-		}
-		return c.json(result);
-	}
+// ─── API Keys ───────────────────────────────────────────────
 
-	// Forward error response
-	const errorBody = await response.text();
-	return c.text(errorBody, response.status as any);
-});
+app.use('/api/v1/api-keys/*', jwtAuth(config.baseUrl));
+app.route('/api/v1/api-keys', createApiKeyRoutes(apiKeysService));
+app.route('/api/v1/api-keys', createApiKeyValidationRoute(apiKeysService));
 
-app.post('/api/v1/auth/login', async (c) => {
-	const body = await c.req.json();
+// ─── Me (GDPR) ──────────────────────────────────────────────
 
-	const signInUrl = new URL('/api/auth/sign-in/email', config.baseUrl);
-	const response = await auth.handler(
-		new Request(signInUrl, {
-			method: 'POST',
-			headers: c.req.raw.headers,
-			body: JSON.stringify({ email: body.email, password: body.password }),
-		})
-	);
+app.use('/api/v1/me/*', jwtAuth(config.baseUrl));
+app.route('/api/v1/me', createMeRoutes(db));
 
-	// Copy Set-Cookie headers for SSO
-	const newResponse = new Response(response.body, {
-		status: response.status,
-		headers: response.headers,
-	});
-	return newResponse;
-});
+// ─── Internal API ───────────────────────────────────────────
 
-app.post('/api/v1/auth/validate', jwtAuth(config.baseUrl), async (c) => {
-	const user = c.get('user');
-	return c.json({ valid: true, payload: user });
-});
+app.use('/api/v1/internal/*', serviceAuth(config.serviceKey));
 
-app.post('/api/v1/auth/logout', async (c) => {
-	const signOutUrl = new URL('/api/auth/sign-out', config.baseUrl);
-	return auth.handler(
-		new Request(signOutUrl, {
-			method: 'POST',
-			headers: c.req.raw.headers,
-		})
-	);
-});
-
-app.get('/api/v1/auth/session', async (c) => {
-	const sessionUrl = new URL('/api/auth/get-session', config.baseUrl);
-	return auth.handler(
-		new Request(sessionUrl, {
-			method: 'GET',
-			headers: c.req.raw.headers,
-		})
-	);
-});
-
-// ─── Internal API (service-to-service) ──────────────────────
-
-app.get('/api/v1/internal/org/:orgId/member/:userId', serviceAuth(config.serviceKey), async (c) => {
+app.get('/api/v1/internal/org/:orgId/member/:userId', async (c) => {
 	const { orgId, userId } = c.req.param();
-	// Query members table directly
-	const { eq, and } = await import('drizzle-orm');
 	const { members } = await import('./db/schema/organizations');
+	const { eq, and } = await import('drizzle-orm');
 	const [member] = await db
 		.select()
 		.from(members)
 		.where(and(eq(members.organizationId, orgId), eq(members.userId, userId)))
 		.limit(1);
-
-	return c.json({
-		isMember: !!member,
-		role: member?.role || '',
-	});
+	return c.json({ isMember: !!member, role: member?.role || '' });
 });
 
-// ─── Login Page (for OIDC) ──────────────────────────────────
+// ─── Login Page (OIDC) ─────────────────────────────────────
 
 app.get('/login', (c) => {
-	const query = c.req.query();
+	const q = c.req.query();
 	return c.html(`<!DOCTYPE html>
 <html><head><title>ManaCore Login</title></head>
 <body style="font-family:system-ui;max-width:400px;margin:80px auto;padding:20px;">
 <h1>ManaCore Login</h1>
 <form method="POST" action="/api/auth/sign-in/email">
-<input type="hidden" name="callbackURL" value="${query.callbackURL || '/'}" />
+<input type="hidden" name="callbackURL" value="${q.callbackURL || '/'}" />
 <label>Email<br><input type="email" name="email" required style="width:100%;padding:8px;margin:4px 0 12px;"></label>
 <label>Password<br><input type="password" name="password" required style="width:100%;padding:8px;margin:4px 0 12px;"></label>
 <button type="submit" style="width:100%;padding:10px;background:#3b82f6;color:white;border:none;cursor:pointer;">Login</button>
-</form>
-</body></html>`);
+</form></body></html>`);
 });
 
 // ─── Start ──────────────────────────────────────────────────
 
 console.log(`mana-auth starting on port ${config.port}...`);
 
-export default {
-	port: config.port,
-	fetch: app.fetch,
-};
+export default { port: config.port, fetch: app.fetch };
diff --git a/services/mana-auth/src/routes/api-keys.ts b/services/mana-auth/src/routes/api-keys.ts
new file mode 100644
index 000000000..4feaa9443
--- /dev/null
+++ b/services/mana-auth/src/routes/api-keys.ts
@@ -0,0 +1,33 @@
+/**
+ * API Key routes — Service-to-service authentication keys
+ */
+
+import { Hono } from 'hono';
+import type { ApiKeysService } from '../services/api-keys';
+import type { AuthUser } from '../middleware/jwt-auth';
+
+export function createApiKeyRoutes(apiKeysService: ApiKeysService) {
+	return new Hono<{ Variables: { user: AuthUser } }>()
+		.get('/', async (c) => {
+			const user = c.get('user');
+			return c.json(await apiKeysService.listUserApiKeys(user.userId));
+		})
+		.post('/', async (c) => {
+			const user = c.get('user');
+			const body = await c.req.json();
+			const result = await apiKeysService.createApiKey(user.userId, body);
+			return c.json(result, 201);
+		})
+		.delete('/:id', async (c) => {
+			const user = c.get('user');
+			return c.json(await apiKeysService.revokeApiKey(user.userId, c.req.param('id')));
+		});
+}
+
+/** Validation route — no JWT required, uses API key itself */
+export function createApiKeyValidationRoute(apiKeysService: ApiKeysService) {
+	return new Hono().post('/validate', async (c) => {
+		const { apiKey, scope } = await c.req.json();
+		return c.json(await apiKeysService.validateApiKey(apiKey, scope));
+	});
+}
diff --git a/services/mana-auth/src/routes/auth.ts b/services/mana-auth/src/routes/auth.ts
new file mode 100644
index 000000000..6487ab7a0
--- /dev/null
+++ b/services/mana-auth/src/routes/auth.ts
@@ -0,0 +1,236 @@
+/**
+ * Auth routes — Custom endpoints wrapping Better Auth
+ *
+ * Adds business logic (security events, lockout, credit init)
+ * around Better Auth's native sign-in/sign-up.
+ */
+
+import { Hono } from 'hono';
+import type { AuthUser } from '../middleware/jwt-auth';
+import type { BetterAuthInstance } from '../auth/better-auth.config';
+import type { SecurityEventsService, AccountLockoutService } from '../services/security';
+import type { Config } from '../config';
+import { sourceAppStore, passwordResetRedirectStore } from '../auth/stores';
+
+export function createAuthRoutes(
+	auth: BetterAuthInstance,
+	config: Config,
+	security: SecurityEventsService,
+	lockout: AccountLockoutService
+) {
+	const app = new Hono<{ Variables: { user: AuthUser } }>();
+
+	// ─── Registration ────────────────────────────────────────
+
+	app.post('/register', async (c) => {
+		const body = await c.req.json();
+
+		// Store source app URL for email verification redirect
+		if (body.sourceAppUrl && body.email) {
+			sourceAppStore.set(body.email, body.sourceAppUrl);
+		}
+
+		const response = await auth.api.signUpEmail({
+			body: {
+				email: body.email,
+				password: body.password,
+				name: body.name || body.email.split('@')[0],
+			},
+			headers: c.req.raw.headers,
+		});
+
+		if (response?.user?.id) {
+			security.logEvent({ userId: response.user.id, eventType: 'REGISTER' });
+			// Init credits (fire-and-forget)
+			fetch(`${config.manaCreditsUrl}/api/v1/internal/credits/init`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json', 'X-Service-Key': config.serviceKey },
+				body: JSON.stringify({ userId: response.user.id }),
+			}).catch(() => {});
+			// Redeem pending gifts
+			fetch(`${config.manaCreditsUrl}/api/v1/internal/gifts/redeem-pending`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json', 'X-Service-Key': config.serviceKey },
+				body: JSON.stringify({ userId: response.user.id, email: body.email }),
+			}).catch(() => {});
+		}
+
+		return c.json(response);
+	});
+
+	// ─── Login ───────────────────────────────────────────────
+
+	app.post('/login', async (c) => {
+		const body = await c.req.json();
+
+		// Check lockout
+		const lockoutStatus = await lockout.checkLockout(body.email);
+		if (lockoutStatus.locked) {
+			return c.json(
+				{ error: 'Account locked', remainingSeconds: lockoutStatus.remainingSeconds },
+				429
+			);
+		}
+
+		const ip = c.req.header('x-forwarded-for') || 'unknown';
+
+		try {
+			const response = await auth.api.signInEmail({
+				body: { email: body.email, password: body.password },
+				headers: c.req.raw.headers,
+			});
+
+			if (response?.user?.id) {
+				security.logEvent({ userId: response.user.id, eventType: 'LOGIN_SUCCESS', ipAddress: ip });
+				lockout.clearAttempts(body.email);
+			}
+
+			return c.json(response);
+		} catch (error) {
+			security.logEvent({
+				eventType: 'LOGIN_FAILURE',
+				ipAddress: ip,
+				metadata: { email: body.email },
+			});
+			lockout.recordAttempt(body.email, false, ip);
+			return c.json({ error: 'Invalid credentials' }, 401);
+		}
+	});
+
+	// ─── Token Validation ────────────────────────────────────
+
+	app.post('/validate', async (c) => {
+		const { token } = await c.req.json();
+		if (!token) return c.json({ valid: false }, 400);
+
+		try {
+			const { jwtVerify, createRemoteJWKSet } = await import('jose');
+			const jwks = createRemoteJWKSet(new URL('/api/auth/jwks', config.baseUrl));
+			const { payload } = await jwtVerify(token, jwks, {
+				issuer: config.baseUrl,
+				audience: 'manacore',
+			});
+			return c.json({ valid: true, payload });
+		} catch {
+			return c.json({ valid: false }, 401);
+		}
+	});
+
+	// ─── Session & Logout ────────────────────────────────────
+
+	app.post('/logout', async (c) => {
+		return auth.handler(
+			new Request(new URL('/api/auth/sign-out', config.baseUrl), {
+				method: 'POST',
+				headers: c.req.raw.headers,
+			})
+		);
+	});
+
+	app.get('/session', async (c) => {
+		return auth.handler(
+			new Request(new URL('/api/auth/get-session', config.baseUrl), {
+				method: 'GET',
+				headers: c.req.raw.headers,
+			})
+		);
+	});
+
+	app.post('/refresh', async (c) => {
+		const body = await c.req.json();
+		// Better Auth handles refresh via session cookies
+		return auth.handler(
+			new Request(new URL('/api/auth/get-session', config.baseUrl), {
+				method: 'GET',
+				headers: c.req.raw.headers,
+			})
+		);
+	});
+
+	// ─── Password Management ─────────────────────────────────
+
+	app.post('/forgot-password', async (c) => {
+		const body = await c.req.json();
+		if (body.redirectTo && body.email) {
+			passwordResetRedirectStore.set(body.email, body.redirectTo);
+		}
+		await auth.api.forgetPassword({ body: { email: body.email, redirectTo: body.redirectTo } });
+		security.logEvent({ eventType: 'PASSWORD_RESET_REQUESTED', metadata: { email: body.email } });
+		return c.json({ success: true });
+	});
+
+	app.post('/reset-password', async (c) => {
+		const body = await c.req.json();
+		await auth.api.resetPassword({ body: { newPassword: body.newPassword, token: body.token } });
+		security.logEvent({ eventType: 'PASSWORD_RESET_COMPLETED' });
+		return c.json({ success: true });
+	});
+
+	app.post('/resend-verification', async (c) => {
+		const body = await c.req.json();
+		if (body.sourceAppUrl && body.email) {
+			sourceAppStore.set(body.email, body.sourceAppUrl);
+		}
+		await auth.api.sendVerificationEmail({ body: { email: body.email } });
+		return c.json({ success: true });
+	});
+
+	// ─── Profile ─────────────────────────────────────────────
+
+	app.get('/profile', async (c) => {
+		return auth.handler(
+			new Request(new URL('/api/auth/get-session', config.baseUrl), {
+				method: 'GET',
+				headers: c.req.raw.headers,
+			})
+		);
+	});
+
+	app.post('/profile', async (c) => {
+		const body = await c.req.json();
+		const result = await auth.api.updateUser({ body, headers: c.req.raw.headers });
+		security.logEvent({ eventType: 'PROFILE_UPDATED' });
+		return c.json(result);
+	});
+
+	app.post('/change-password', async (c) => {
+		const body = await c.req.json();
+		await auth.api.changePassword({
+			body: { currentPassword: body.currentPassword, newPassword: body.newPassword },
+			headers: c.req.raw.headers,
+		});
+		security.logEvent({ eventType: 'PASSWORD_CHANGED' });
+		return c.json({ success: true });
+	});
+
+	app.delete('/account', async (c) => {
+		const body = await c.req.json();
+		await auth.api.deleteUser({
+			body: { password: body.password },
+			headers: c.req.raw.headers,
+		});
+		security.logEvent({ eventType: 'ACCOUNT_DELETED' });
+		return c.json({ success: true });
+	});
+
+	// ─── Security Events ─────────────────────────────────────
+
+	app.get('/security-events', async (c) => {
+		const user = c.get('user');
+		const events = await security.getUserEvents(user.userId);
+		return c.json(events);
+	});
+
+	// ─── JWKS ────────────────────────────────────────────────
+
+	app.get('/jwks', async (c) => {
+		return auth.handler(
+			new Request(new URL('/api/auth/jwks', config.baseUrl), {
+				method: 'GET',
+				headers: c.req.raw.headers,
+			})
+		);
+	});
+
+	return app;
+}
diff --git a/services/mana-auth/src/routes/guilds.ts b/services/mana-auth/src/routes/guilds.ts
new file mode 100644
index 000000000..ea948ed42
--- /dev/null
+++ b/services/mana-auth/src/routes/guilds.ts
@@ -0,0 +1,108 @@
+/**
+ * Guild routes — Organization management with shared Mana pools
+ */
+
+import { Hono } from 'hono';
+import type { AuthUser } from '../middleware/jwt-auth';
+import type { Config } from '../config';
+import type { BetterAuthInstance } from '../auth/better-auth.config';
+
+export function createGuildRoutes(auth: BetterAuthInstance, config: Config) {
+	return new Hono<{ Variables: { user: AuthUser } }>()
+		.post('/', async (c) => {
+			const user = c.get('user');
+			const body = await c.req.json();
+
+			// Check subscription limits
+			const limitsRes = await fetch(
+				`${config.manaSubscriptionsUrl}/api/v1/internal/plan-limits/${user.userId}`,
+				{ headers: { 'X-Service-Key': config.serviceKey } }
+			).catch(() => null);
+			const limits = limitsRes?.ok ? await limitsRes.json() : { maxOrganizations: 1 };
+
+			// Create org via Better Auth
+			const result = await auth.api.createOrganization({
+				body: { name: body.name, slug: body.slug, logo: body.logo },
+				headers: c.req.raw.headers,
+			});
+
+			// Init guild pool via mana-credits
+			if (result?.id) {
+				fetch(`${config.manaCreditsUrl}/api/v1/internal/guild-pool/init`, {
+					method: 'POST',
+					headers: { 'Content-Type': 'application/json', 'X-Service-Key': config.serviceKey },
+					body: JSON.stringify({ organizationId: result.id }),
+				}).catch(() => {});
+			}
+
+			return c.json({ gilde: result, pool: { balance: 0 } }, 201);
+		})
+		.get('/', async (c) => {
+			const result = await auth.api.listOrganizations({ headers: c.req.raw.headers });
+			return c.json(result);
+		})
+		.get('/:id', async (c) => {
+			const result = await auth.api.getFullOrganization({
+				query: { organizationId: c.req.param('id') },
+				headers: c.req.raw.headers,
+			});
+			return c.json(result);
+		})
+		.put('/:id', async (c) => {
+			const body = await c.req.json();
+			const result = await auth.api.updateOrganization({
+				body: { organizationId: c.req.param('id'), data: body },
+				headers: c.req.raw.headers,
+			});
+			return c.json(result);
+		})
+		.delete('/:id', async (c) => {
+			await auth.api.deleteOrganization({
+				body: { organizationId: c.req.param('id') },
+				headers: c.req.raw.headers,
+			});
+			return c.json({ success: true });
+		})
+		.post('/:id/invite', async (c) => {
+			const body = await c.req.json();
+			const result = await auth.api.createInvitation({
+				body: {
+					organizationId: c.req.param('id'),
+					email: body.email,
+					role: body.role || 'member',
+				},
+				headers: c.req.raw.headers,
+			});
+			return c.json(result);
+		})
+		.post('/accept-invitation', async (c) => {
+			const { invitationId } = await c.req.json();
+			const result = await auth.api.acceptInvitation({
+				body: { invitationId },
+				headers: c.req.raw.headers,
+			});
+			return c.json(result);
+		})
+		.delete('/:id/members/:memberId', async (c) => {
+			await auth.api.removeMember({
+				body: {
+					organizationId: c.req.param('id'),
+					memberIdOrEmail: c.req.param('memberId'),
+				},
+				headers: c.req.raw.headers,
+			});
+			return c.json({ success: true });
+		})
+		.put('/:id/members/:memberId/role', async (c) => {
+			const { role } = await c.req.json();
+			const result = await auth.api.updateMemberRole({
+				body: {
+					organizationId: c.req.param('id'),
+					memberId: c.req.param('memberId'),
+					role,
+				},
+				headers: c.req.raw.headers,
+			});
+			return c.json(result);
+		});
+}
diff --git a/services/mana-auth/src/routes/me.ts b/services/mana-auth/src/routes/me.ts
new file mode 100644
index 000000000..c91bf40b3
--- /dev/null
+++ b/services/mana-auth/src/routes/me.ts
@@ -0,0 +1,49 @@
+/**
+ * Me routes — GDPR self-service data management
+ */
+
+import { Hono } from 'hono';
+import { sql } from 'drizzle-orm';
+import type { AuthUser } from '../middleware/jwt-auth';
+import type { Database } from '../db/connection';
+import { sendAccountDeletionEmail } from '../email/send';
+
+export function createMeRoutes(db: Database) {
+	return new Hono<{ Variables: { user: AuthUser } }>()
+		.get('/data', async (c) => {
+			const user = c.get('user');
+			// Return basic user data summary
+			const result = await db.execute(
+				sql`SELECT id, email, name, role, created_at FROM auth.users WHERE id = ${user.userId}`
+			);
+			return c.json({ user: (result as any)[0] || null });
+		})
+		.get('/data/export', async (c) => {
+			const user = c.get('user');
+			const [userData] = (await db.execute(
+				sql`SELECT * FROM auth.users WHERE id = ${user.userId}`
+			)) as any[];
+			const sessions = await db.execute(
+				sql`SELECT id, created_at, expires_at, ip_address FROM auth.sessions WHERE user_id = ${user.userId}`
+			);
+			const securityEvents = await db.execute(
+				sql`SELECT event_type, ip_address, created_at FROM auth.security_events WHERE user_id = ${user.userId} ORDER BY created_at DESC LIMIT 100`
+			);
+
+			return c.json({
+				exportedAt: new Date().toISOString(),
+				exportVersion: '1.0',
+				user: userData,
+				sessions,
+				securityEvents,
+			});
+		})
+		.delete('/data', async (c) => {
+			const user = c.get('user');
+			// Delete user (cascades via FK)
+			await db.execute(sql`DELETE FROM auth.users WHERE id = ${user.userId}`);
+			// Send confirmation email
+			sendAccountDeletionEmail(user.email).catch(() => {});
+			return c.json({ success: true, message: 'Account and all data deleted' });
+		});
+}
diff --git a/services/mana-auth/src/services/api-keys.ts b/services/mana-auth/src/services/api-keys.ts
new file mode 100644
index 000000000..5ba81c479
--- /dev/null
+++ b/services/mana-auth/src/services/api-keys.ts
@@ -0,0 +1,103 @@
+/**
+ * API Keys Service — Generate, validate, revoke service API keys
+ */
+
+import { eq, and, isNull, sql } from 'drizzle-orm';
+import { randomBytes, createHash } from 'crypto';
+import type { Database } from '../db/connection';
+import { NotFoundError } from '../lib/errors';
+
+// Schema imported inline to avoid circular deps
+import { apiKeys } from '../db/schema/api-keys';
+
+export class ApiKeysService {
+	constructor(private db: Database) {}
+
+	private generateKey(): string {
+		return `sk_live_${randomBytes(32).toString('hex')}`;
+	}
+
+	private hashKey(key: string): string {
+		return createHash('sha256').update(key).digest('hex');
+	}
+
+	private getKeyPrefix(key: string): string {
+		return key.replace('sk_live_', '').slice(0, 8);
+	}
+
+	async listUserApiKeys(userId: string) {
+		return this.db
+			.select({
+				id: apiKeys.id,
+				name: apiKeys.name,
+				keyPrefix: apiKeys.keyPrefix,
+				scopes: apiKeys.scopes,
+				createdAt: apiKeys.createdAt,
+				lastUsedAt: apiKeys.lastUsedAt,
+				revokedAt: apiKeys.revokedAt,
+			})
+			.from(apiKeys)
+			.where(eq(apiKeys.userId, userId));
+	}
+
+	async createApiKey(userId: string, data: { name: string; scopes?: string[] }) {
+		const key = this.generateKey();
+		const hash = this.hashKey(key);
+		const prefix = this.getKeyPrefix(key);
+
+		const [created] = await this.db
+			.insert(apiKeys)
+			.values({
+				userId,
+				name: data.name,
+				keyHash: hash,
+				keyPrefix: prefix,
+				scopes: data.scopes || ['stt', 'tts'],
+			})
+			.returning();
+
+		return { ...created, key }; // Full key returned ONLY on creation
+	}
+
+	async revokeApiKey(userId: string, keyId: string) {
+		const [revoked] = await this.db
+			.update(apiKeys)
+			.set({ revokedAt: new Date() })
+			.where(and(eq(apiKeys.id, keyId), eq(apiKeys.userId, userId)))
+			.returning();
+
+		if (!revoked) throw new NotFoundError('API key not found');
+		return { success: true };
+	}
+
+	async validateApiKey(apiKey: string, scope?: string) {
+		const hash = this.hashKey(apiKey);
+
+		const [key] = await this.db
+			.select()
+			.from(apiKeys)
+			.where(and(eq(apiKeys.keyHash, hash), isNull(apiKeys.revokedAt)))
+			.limit(1);
+
+		if (!key) return { valid: false };
+
+		// Check scope if provided
+		if (scope && key.scopes && !(key.scopes as string[]).includes(scope)) {
+			return { valid: false, reason: 'scope_denied' };
+		}
+
+		// Update lastUsedAt (fire-and-forget)
+		this.db
+			.update(apiKeys)
+			.set({ lastUsedAt: new Date() })
+			.where(eq(apiKeys.id, key.id))
+			.catch(() => {});
+
+		return {
+			valid: true,
+			userId: key.userId,
+			scopes: key.scopes,
+			rateLimit: { requests: 60, window: 60 },
+		};
+	}
+}
diff --git a/services/mana-auth/src/services/security.ts b/services/mana-auth/src/services/security.ts
new file mode 100644
index 000000000..bb91555b6
--- /dev/null
+++ b/services/mana-auth/src/services/security.ts
@@ -0,0 +1,115 @@
+/**
+ * Security Services — Audit logging + Account lockout
+ */
+
+import { eq, and, gte, desc, sql } from 'drizzle-orm';
+import type { Database } from '../db/connection';
+
+// Security events — fire-and-forget, never throw
+const EVENT_TYPES = [
+	'LOGIN_SUCCESS',
+	'LOGIN_FAILURE',
+	'REGISTER',
+	'LOGOUT',
+	'PASSWORD_CHANGED',
+	'PASSWORD_RESET_REQUESTED',
+	'PASSWORD_RESET_COMPLETED',
+	'EMAIL_VERIFIED',
+	'ACCOUNT_DELETED',
+	'ACCOUNT_LOCKED',
+	'PROFILE_UPDATED',
+	'API_KEY_CREATED',
+	'API_KEY_REVOKED',
+	'PASSKEY_REGISTERED',
+	'PASSKEY_LOGIN_SUCCESS',
+	'TWO_FACTOR_ENABLED',
+	'TWO_FACTOR_DISABLED',
+	'ORG_CREATED',
+	'ORG_DELETED',
+] as const;
+
+export class SecurityEventsService {
+	constructor(private db: Database) {}
+
+	async logEvent(params: {
+		userId?: string;
+		eventType: string;
+		ipAddress?: string;
+		userAgent?: string;
+		metadata?: Record<string, unknown>;
+	}) {
+		try {
+			// Use raw SQL since securityEvents table may be in auth schema
+			await this.db.execute(
+				sql`INSERT INTO auth.security_events (id, user_id, event_type, ip_address, user_agent, metadata, created_at)
+				VALUES (gen_random_uuid(), ${params.userId}, ${params.eventType}, ${params.ipAddress}, ${params.userAgent}, ${JSON.stringify(params.metadata || {})}::jsonb, NOW())`
+			);
+		} catch (error) {
+			console.warn('Failed to log security event (non-critical):', params.eventType);
+		}
+	}
+
+	async getUserEvents(userId: string, limit = 50) {
+		try {
+			const result = await this.db.execute(
+				sql`SELECT * FROM auth.security_events WHERE user_id = ${userId} ORDER BY created_at DESC LIMIT ${limit}`
+			);
+			return result;
+		} catch {
+			return [];
+		}
+	}
+}
+
+// Lockout policy: 5 failures in 15 min → locked 30 min
+const MAX_ATTEMPTS = 5;
+const WINDOW_MINUTES = 15;
+const LOCKOUT_MINUTES = 30;
+
+export class AccountLockoutService {
+	constructor(private db: Database) {}
+
+	async checkLockout(email: string): Promise<{ locked: boolean; remainingSeconds?: number }> {
+		try {
+			const windowStart = new Date(Date.now() - WINDOW_MINUTES * 60 * 1000);
+			const result = await this.db.execute(
+				sql`SELECT COUNT(*) as count, MAX(attempted_at) as last_attempt
+				FROM auth.login_attempts
+				WHERE email = ${email} AND successful = false AND attempted_at > ${windowStart}`
+			);
+
+			const row = (result as any)[0];
+			if (!row || Number(row.count) < MAX_ATTEMPTS) return { locked: false };
+
+			const lastAttempt = new Date(row.last_attempt);
+			const lockoutEnd = new Date(lastAttempt.getTime() + LOCKOUT_MINUTES * 60 * 1000);
+			if (Date.now() > lockoutEnd.getTime()) return { locked: false };
+
+			return {
+				locked: true,
+				remainingSeconds: Math.ceil((lockoutEnd.getTime() - Date.now()) / 1000),
+			};
+		} catch {
+			return { locked: false };
+		}
+	}
+
+	async recordAttempt(email: string, successful: boolean, ipAddress?: string) {
+		try {
+			await this.db.execute(
+				sql`INSERT INTO auth.login_attempts (id, email, successful, ip_address, attempted_at)
+				VALUES (gen_random_uuid(), ${email}, ${successful}, ${ipAddress}, NOW())`
+			);
+		} catch {
+			// Non-critical
+		}
+	}
+
+	async clearAttempts(email: string) {
+		try {
+			await this.db.execute(sql`DELETE FROM auth.login_attempts WHERE email = ${email}`);
+		} catch {
+			// Non-critical
+		}
+	}
+}