feat: Gate 0 - modular route-based server architecture

Refactor monolithic proxyServer.ts (1128 lines) into pluggable handlers:
- NEW src/server/router.ts: Route registry + request handler factory
- NEW src/server/state.ts: Shared request logs + cost tracking
- NEW src/server/metrics.ts: Prometheus-compatible metrics
- NEW src/server/handlers/chatHandler.ts: POST /v1/chat/completions
- NEW src/server/handlers/completionsHandler.ts: POST /v1/completions
- NEW src/server/handlers/embeddingsHandler.ts: POST /v1/embeddings
- NEW src/server/handlers/modelsHandler.ts: GET /v1/models
- NEW src/server/handlers/healthHandler.ts: GET /health
- NEW src/server/handlers/metricsHandler.ts: GET /metrics
- proxyServer.ts: now uses registerRoute() + createRequestHandler()

New endpoint addition = 2 lines (import + registerRoute call).

Also:
- Fix skill_manager.test.ts Python docstring -> TypeScript JSDoc
- Update README with new server architecture + API endpoints
- Bump version to 2.15.0
- npm publish adaptive-memory-multi-model-router@2.15.0

Author: Das-rebel

README.md

@@ -109,6 +109,28 @@ A3M Router operates as a stateless proxy between client applications and LLM pro
 3. **Routing decision** — Multi-signal heuristic scoring assigns a complexity score (0.0–1.0) to the query. The score maps to a provider tier. The router selects the cheapest available provider in that tier.
 4. **Execution** — The LLM call is issued to the selected provider. Results are returned with routing metadata.
 
+### Server Architecture
+
+The proxy server uses a modular route-based architecture for maintainability and extensibility:
+
+```
+src/server/
+├── proxyServer.ts       # Entry point + route registration
+├── router.ts           # Route registry + request handler factory
+├── state.ts            # Shared request logs + cost tracking
+├── metrics.ts          # Prometheus-compatible metrics
+├── modelMapper.ts      # Model resolution + provider selection
+└── handlers/
+    ├── chatHandler.ts      # POST /v1/chat/completions
+    ├── completionsHandler.ts  # POST /v1/completions
+    ├── embeddingsHandler.ts  # POST /v1/embeddings
+    ├── modelsHandler.ts   # GET /v1/models
+    ├── healthHandler.ts   # GET /health
+    └── metricsHandler.ts # GET /metrics
+```
+
+Adding a new endpoint = 2 lines: import the handler + call `registerRoute()`.
+
 ### Routing Signals
 
 The complexity score is computed as a weighted sum across five signal dimensions:
@@ -257,9 +279,12 @@ npx a3m-router health                           # provider health status and lat
 | Method | Endpoint | Description |
 |--------|----------|-------------|
 | POST | `/v1/chat/completions` | OpenAI-compatible chat (streaming + non-streaming) |
+| POST | `/v1/completions` | OpenAI-compatible completions |
+| POST | `/v1/embeddings` | OpenAI-compatible embeddings |
 | POST | `/v1/route` | Routing decision without LLM call |
 | GET | `/v1/models` | Available models with pricing |
-| GET | `/health` | Provider health scores |
+| GET | `/health` | Health check with provider status + recent requests |
+| GET | `/metrics` | Prometheus-compatible metrics |
 
 Full documentation: [`docs/API.md`](docs/API.md)
 

dist/analytics/costAnalytics.d.ts

@@ -75,3 +75,4 @@ export declare class CostAnalytics {
     private getDaysCovered;
 }
 export declare function createCostAnalytics(maxRecords?: number): CostAnalytics;
+//# sourceMappingURL=costAnalytics.d.ts.map

dist/benchmark/comprehensive.d.ts

@@ -1,56 +1,7 @@
 /**
  * A3M Router — Comprehensive Local Benchmark Suite
- *
- * Tests 4 dimensions where A3M claims leadership:
- *   1. Routing Accuracy (tier assignment)
- *   2. Memory Persistence (cross-session recall)
- *   3. Robustness (failover, circuit breaker, provider health)
- *   4. Cost Efficiency (vs always-premium baseline)
- *
- * Run: npx ts-node src/benchmark/comprehensive.ts
+ * Tests: Routing Accuracy, Memory Persistence, Robustness, Cost Efficiency
+ * Run: npx ts-node -P tsconfig.build.json src/benchmark/comprehensive.ts
  */
-interface RoutingResult {
-    query: string;
-    actualTier: string;
-    routedTier: string;
-    model: string;
-    complexity: number;
-    cost: number;
-    correct: boolean;
-    offByOne: boolean;
-}
-declare function runRoutingAccuracy(): {
-    results: RoutingResult[];
-    summary: any;
-};
-interface MemoryTestResult {
-    test: string;
-    passed: boolean;
-    details: string;
-}
-declare function runMemoryBenchmark(): {
-    results: MemoryTestResult[];
-    summary: any;
-};
-interface RobustnessResult {
-    test: string;
-    passed: boolean;
-    details: string;
-}
-declare function runRobustnessBenchmark(): {
-    results: RobustnessResult[];
-    summary: any;
-};
-interface CostResult {
-    scenario: string;
-    a3mCost: number;
-    alwaysPremiumCost: number;
-    savings: number;
-    savingsPct: number;
-}
-declare function runCostBenchmark(): {
-    results: CostResult[];
-    summary: any;
-};
-export declare function runComprehensiveBenchmark(): void;
-export { runRoutingAccuracy, runMemoryBenchmark, runRobustnessBenchmark, runCostBenchmark };
+export {};
+//# sourceMappingURL=comprehensive.d.ts.map