feat: auth middleware, brain data layer, Valkey queue (P1-002, P1-003, P1-004)

Auth middleware (P1-002):
- DatabaseModule provides Db instance with graceful shutdown
- AuthModule mounts BetterAuth at /api/auth/* via toNodeHandler
- AuthGuard validates sessions via BetterAuth API
- CurrentUser decorator extracts user from request

Brain data layer (P1-003):
- CRUD repositories for projects, missions, tasks, conversations
- createBrain(db) factory returns all repositories
- Re-exports drizzle-orm query helpers from @mosaic/db to avoid
  duplicate package resolution

Queue (P1-004):
- ioredis-based Valkey client with createQueue/createQueueClient
- Enqueue/dequeue, pub/sub, queue length operations

Closes #11, Closes #12, Closes #13

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

packages/queue/package.json

@@ -16,7 +16,8 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@mosaic/types": "workspace:*"
+    "@mosaic/types": "workspace:*",
+    "ioredis": "^5.10.0"
   },
   "devDependencies": {
     "typescript": "^5.8.0",

packages/queue/src/index.ts

@@ -1 +1,8 @@
-export const VERSION = '0.0.0';
+export {
+  createQueue,
+  createQueueClient,
+  type QueueConfig,
+  type QueueHandle,
+  type QueueClient,
+  type TaskPayload,
+} from './queue.js';

packages/queue/src/queue.ts

@@ -0,0 +1,67 @@
+import Redis from 'ioredis';
+
+const DEFAULT_VALKEY_URL = 'redis://localhost:6380';
+
+export interface QueueConfig {
+  url?: string;
+}
+
+export interface QueueHandle {
+  redis: Redis;
+  close: () => Promise<void>;
+}
+
+export interface TaskPayload {
+  id: string;
+  type: string;
+  data: Record<string, unknown>;
+  createdAt: string;
+}
+
+export function createQueue(config?: QueueConfig): QueueHandle {
+  const url = config?.url ?? process.env['VALKEY_URL'] ?? DEFAULT_VALKEY_URL;
+  const redis = new Redis(url, { maxRetriesPerRequest: 3 });
+
+  return {
+    redis,
+    close: async () => {
+      await redis.quit();
+    },
+  };
+}
+
+export function createQueueClient(handle: QueueHandle) {
+  const { redis } = handle;
+
+  return {
+    async enqueue(queueName: string, payload: TaskPayload): Promise<void> {
+      await redis.lpush(queueName, JSON.stringify(payload));
+    },
+
+    async dequeue(queueName: string): Promise<TaskPayload | null> {
+      const item = await redis.rpop(queueName);
+      if (!item) return null;
+      return JSON.parse(item) as TaskPayload;
+    },
+
+    async length(queueName: string): Promise<number> {
+      return redis.llen(queueName);
+    },
+
+    async publish(channel: string, message: string): Promise<void> {
+      await redis.publish(channel, message);
+    },
+
+    subscribe(channel: string, handler: (message: string) => void): () => void {
+      const sub = redis.duplicate();
+      sub.subscribe(channel).catch(() => {});
+      sub.on('message', (_ch: string, msg: string) => handler(msg));
+      return () => {
+        sub.unsubscribe(channel).catch(() => {});
+        sub.disconnect();
+      };
+    },
+  };
+}
+
+export type QueueClient = ReturnType<typeof createQueueClient>;