baselineos 0.2.0-beta.1

package/dist/api/server.js

@@ -0,0 +1,1007 @@
+import express from 'express';
+import { WebSocketServer, WebSocket } from 'ws';
+import { createServer } from 'http';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { trace, propagation, context } from '@opentelemetry/api';
+
+// src/api/server.ts
+var _sdk = null;
+function initTelemetry() {
+  if (_sdk || process.env["BASELINE_OTEL_DISABLED"] === "1") return;
+  const endpoint = process.env["OTEL_EXPORTER_OTLP_ENDPOINT"] ?? "http://localhost:4318";
+  const exporter = new OTLPTraceExporter({
+    url: `${endpoint}/v1/traces`
+  });
+  _sdk = new NodeSDK({
+    resource: resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: process.env["OTEL_SERVICE_NAME"] ?? "baselineos",
+      [ATTR_SERVICE_VERSION]: "0.2.0-beta.1"
+    }),
+    traceExporter: exporter
+    // W3C traceparent propagation is the default — no explicit config needed
+  });
+  _sdk.start();
+  process.on("SIGTERM", () => {
+    _sdk?.shutdown().catch(() => {
+    });
+  });
+  process.on("SIGINT", () => {
+    _sdk?.shutdown().catch(() => {
+    });
+  });
+}
+new Proxy({}, {
+  get(_target, prop) {
+    return trace.getTracer("baselineos", "0.2.0-beta.1")[prop];
+  }
+});
+function extractTraceContext() {
+  const carrier = {};
+  propagation.inject(context.active(), carrier);
+  return carrier["traceparent"];
+}
+
+// src/api/server.ts
+var TASK_STATUSES = [
+  "pending",
+  "planning",
+  "executing",
+  "verifying",
+  "reviewing",
+  "correcting",
+  "completed",
+  "failed",
+  "blocked"
+];
+var CONTEXT_LEVELS = ["oneliner", "summary", "working", "full", "expanded"];
+var MEMORY_SCOPES = ["working", "session", "long-term", "shared", "all"];
+function parseTaskStatus(value) {
+  return typeof value === "string" && TASK_STATUSES.includes(value) ? value : void 0;
+}
+function parseContextLevel(value) {
+  if (typeof value === "string" && CONTEXT_LEVELS.includes(value)) {
+    return value;
+  }
+  return "working";
+}
+function parseScope(value) {
+  if (typeof value === "string" && MEMORY_SCOPES.includes(value)) {
+    return value;
+  }
+  return void 0;
+}
+function parseJson(value) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function parsePolicy(value) {
+  if (!value || typeof value !== "object") return void 0;
+  return value;
+}
+function parseBudget(value) {
+  if (!value || typeof value !== "object") return void 0;
+  return value;
+}
+function parseSocketMessage(value) {
+  if (!value || typeof value !== "object") return null;
+  const message = value;
+  if (message.type === "ping") return { type: "ping" };
+  if (message.type === "subscribe") {
+    return {
+      type: "subscribe",
+      taskId: typeof message.taskId === "string" ? message.taskId : void 0
+    };
+  }
+  return null;
+}
+var APIServer = class {
+  app;
+  server;
+  wss;
+  baseline;
+  config;
+  clients;
+  unsubscribeEvents;
+  // ── Prometheus counters (in-process, reset on restart) ──────────────────
+  metricsCounters = {
+    requestsTotal: /* @__PURE__ */ new Map(),
+    // label: "method_path_status"
+    requestDurationMs: /* @__PURE__ */ new Map(),
+    // label: "method"
+    tasksTotal: /* @__PURE__ */ new Map(),
+    // label: task status
+    tokensByAgentRole: /* @__PURE__ */ new Map(),
+    // label: agent role (SIGNAL-013)
+    wsConnections: 0,
+    wsMessagesTotal: 0,
+    serverStartTime: Date.now(),
+    /** Running ratio of autonomous tasks that passed self-verification (SIGNAL-046) */
+    autonomousAccuracy: 1,
+    autonomousTotal: 0,
+    autonomousPassed: 0
+  };
+  /** Optional CostGuard for per-tenant cost metrics (SIGNAL-052) */
+  costGuard;
+  /** Optional TraceCurator for dataset size gauge (SIGNAL-049) */
+  traceCurator;
+  /** Optional ModelVersionRegistry for active model version gauge (SIGNAL-049) */
+  modelVersionRegistry;
+  /** Optional ProductionEvalPipeline for latest eval score gauge (SIGNAL-056) */
+  productionEvalPipeline;
+  /** Optional DriftDetector for model drift metrics (SIGNAL-071) */
+  driftDetector;
+  /** Optional OPAPolicyGate for SLO-6 latency metrics */
+  opaPolicyGate;
+  constructor(baseline, config) {
+    this.baseline = baseline;
+    this.config = config;
+    this.clients = /* @__PURE__ */ new Set();
+    this.unsubscribeEvents = [];
+    initTelemetry();
+    this.app = express();
+    this.server = createServer(this.app);
+    this.wss = new WebSocketServer({ server: this.server, path: "/api/stream" });
+    this.wss.on("error", (error) => {
+      const code = error?.code;
+      if (code !== "EADDRINUSE") {
+        console.error("[WS Error]", error);
+      }
+    });
+    this.setupMiddleware();
+    this.setupRoutes();
+    this.setupWebSocket();
+    this.attachEventBridge();
+  }
+  // ─── Setup ─────────────────────────────────────────────────────────────────
+  setupMiddleware() {
+    this.app.use(express.json());
+    const allowedOrigins = this.config.allowedOrigins ?? ["http://localhost:3000", "http://localhost:3141", "http://localhost:5173", "tauri://localhost"];
+    this.app.use((req, res, next) => {
+      const origin = req.headers.origin;
+      if (origin && allowedOrigins.includes(origin)) {
+        res.header("Access-Control-Allow-Origin", origin);
+      }
+      res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      res.header("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      if (req.method === "OPTIONS") {
+        return res.sendStatus(200);
+      }
+      next();
+    });
+    this.app.use((_req, res, next) => {
+      const traceparent = extractTraceContext();
+      if (traceparent) res.setHeader("traceparent", traceparent);
+      next();
+    });
+    this.app.use((req, res, next) => {
+      const start = Date.now();
+      res.on("finish", () => {
+        const duration = Date.now() - start;
+        console.log(`[API] ${req.method} ${req.path} ${res.statusCode} ${duration}ms`);
+        if (req.path !== "/metrics") {
+          const reqKey = `${req.method}_${res.statusCode}`;
+          this.metricsCounters.requestsTotal.set(
+            reqKey,
+            (this.metricsCounters.requestsTotal.get(reqKey) ?? 0) + 1
+          );
+          const durKey = req.method;
+          const existing = this.metricsCounters.requestDurationMs.get(durKey) ?? [];
+          existing.push(duration);
+          if (existing.length > 1e3) existing.shift();
+          this.metricsCounters.requestDurationMs.set(durKey, existing);
+        }
+      });
+      next();
+    });
+  }
+  setupRoutes() {
+    this.app.get("/api/health", (req, res) => {
+      res.json({ status: "ok", version: "0.2.0-beta.1", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    });
+    this.app.get("/api/ready", (req, res) => {
+      const ready = !!this.baseline;
+      res.status(ready ? 200 : 503).json({
+        ready,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    this.app.post("/api/tasks", this.createTask.bind(this));
+    this.app.get("/api/tasks", this.listTasks.bind(this));
+    this.app.get("/api/tasks/:id", this.getTask.bind(this));
+    this.app.delete("/api/tasks/:id", this.cancelTask.bind(this));
+    this.app.post("/api/tasks/:id/approve", this.approveTask.bind(this));
+    this.app.get("/api/tasks/:id/artifacts", this.getTaskArtifacts.bind(this));
+    this.app.get("/api/tasks/:id/audit", this.getTaskAudit.bind(this));
+    this.app.get("/api/tasks/:id/evidence", this.getTaskEvidence.bind(this));
+    this.app.get("/api/workflows", this.listWorkflows.bind(this));
+    this.app.post("/api/workflows/:id/run", this.runWorkflow.bind(this));
+    this.app.get("/api/checkpoints/:id", this.getCheckpoint.bind(this));
+    this.app.post("/api/checkpoints/:id/recover", this.recoverCheckpoint.bind(this));
+    this.app.get("/api/agents", this.listAgents.bind(this));
+    this.app.post("/api/search", this.search.bind(this));
+    this.app.get("/api/context/:subject", this.getContext.bind(this));
+    this.app.post("/api/index", this.indexKnowledge.bind(this));
+    this.app.post("/api/init", this.initDeployment.bind(this));
+    this.app.post("/api/scan", this.scanDeployment.bind(this));
+    this.app.post("/api/memory", this.remember.bind(this));
+    this.app.get("/api/memory/:key", this.recall.bind(this));
+    this.app.get("/api/stats", this.getStats.bind(this));
+    this.app.get("/metrics", this.getMetrics.bind(this));
+    this.app.use(this.errorHandler.bind(this));
+  }
+  setupWebSocket() {
+    this.wss.on("connection", (ws) => {
+      this.clients.add(ws);
+      console.log("[WS] Client connected");
+      this.metricsCounters.wsConnections++;
+      ws.on("close", () => {
+        this.clients.delete(ws);
+        console.log("[WS] Client disconnected");
+      });
+      ws.on("message", async (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          await this.handleWebSocketMessage(ws, message);
+        } catch {
+          ws.send(JSON.stringify({ error: "Invalid message" }));
+        }
+      });
+      ws.send(JSON.stringify({
+        type: "connected",
+        timestamp: Date.now(),
+        message: "Connected to BaselineOS"
+      }));
+    });
+  }
+  attachEventBridge() {
+    const events = [
+      "task:created",
+      "task:decomposed",
+      "task:assigned",
+      "task:started",
+      "task:checkpoint",
+      "task:verified",
+      "task:review-requested",
+      "task:reviewed",
+      "task:correction-needed",
+      "task:corrected",
+      "task:completed",
+      "task:failed",
+      "task:blocked",
+      "task:approved",
+      "agent:status-changed",
+      "agent:trust-updated",
+      "escalation"
+    ];
+    for (const event of events) {
+      const unsubscribe = this.baseline.onEvent(event, (payload) => {
+        this.broadcast({ ...payload, timestamp: Date.now() });
+        if (event === "task:completed" || event === "task:failed") {
+          const status = event === "task:completed" ? "completed" : "failed";
+          this.metricsCounters.tasksTotal.set(
+            status,
+            (this.metricsCounters.tasksTotal.get(status) ?? 0) + 1
+          );
+          if (event === "task:completed") {
+            const completedPayload = payload;
+            const tokens = completedPayload.task.actualTokens ?? 0;
+            if (tokens > 0 && completedPayload.task.assignedAgent) {
+              const agents = this.baseline.listAgents();
+              const agent = agents.find((a) => a.id === completedPayload.task.assignedAgent);
+              const role = agent?.role ?? "unknown";
+              this.metricsCounters.tokensByAgentRole.set(
+                role,
+                (this.metricsCounters.tokensByAgentRole.get(role) ?? 0) + tokens
+              );
+            }
+            const task = completedPayload.task;
+            if (task.assignedAgent) {
+              this.metricsCounters.autonomousTotal += 1;
+              const hasFailure = task.verificationResults?.some((v) => !v.passed);
+              if (!hasFailure) {
+                this.metricsCounters.autonomousPassed += 1;
+              }
+              this.metricsCounters.autonomousAccuracy = this.metricsCounters.autonomousTotal > 0 ? this.metricsCounters.autonomousPassed / this.metricsCounters.autonomousTotal : 1;
+            }
+          }
+        }
+        if (event === "task:created") {
+          this.metricsCounters.tasksTotal.set(
+            "created",
+            (this.metricsCounters.tasksTotal.get("created") ?? 0) + 1
+          );
+        }
+      });
+      this.unsubscribeEvents.push(unsubscribe);
+    }
+  }
+  // ─── Task Handlers ─────────────────────────────────────────────────────────
+  async createTask(req, res, next) {
+    try {
+      const acceptanceCriteriaInput = Array.isArray(req.body.acceptanceCriteria) ? req.body.acceptanceCriteria : [];
+      const acceptanceCriteria = acceptanceCriteriaInput.filter((item) => typeof item?.description === "string" && item.description.trim().length > 0).map((item, index) => ({
+        description: item.description?.trim() || `Criteria ${index + 1}`,
+        type: item.type ?? "automated",
+        weight: typeof item.weight === "number" ? item.weight : 1
+      }));
+      const input = {
+        title: req.body.title,
+        description: req.body.description,
+        priority: req.body.priority || "medium",
+        requiredCapabilities: Array.isArray(req.body.requiredCapabilities) ? req.body.requiredCapabilities : [],
+        acceptanceCriteria,
+        context: req.body.context && typeof req.body.context === "object" ? req.body.context : {}
+      };
+      const handle = await this.baseline.run(input);
+      this.broadcast({
+        type: "task:created",
+        taskId: handle.id,
+        title: input.title,
+        timestamp: Date.now()
+      });
+      if (req.body.blocking) {
+        const result = await handle.wait(req.body.timeout);
+        res.json({ task: result });
+      } else {
+        res.status(201).json({
+          taskId: handle.id,
+          status: handle.status
+        });
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+  async listTasks(req, res, next) {
+    try {
+      const status = parseTaskStatus(req.query.status);
+      const tasks = this.baseline.listTasks(status ? { status } : void 0);
+      res.json({
+        tasks: tasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+          status: t.status,
+          priority: t.priority,
+          complexity: t.complexity,
+          createdAt: t.createdAt,
+          completedAt: t.completedAt
+        }))
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async getTask(req, res, next) {
+    try {
+      const task = this.baseline.getTask(req.params.id);
+      if (!task) {
+        res.status(404).json({ error: "not_found", message: "Task not found" });
+        return;
+      }
+      res.json({ task });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async cancelTask(req, res, next) {
+    try {
+      const cancelled = this.baseline.cancelTask(
+        req.params.id,
+        typeof req.body?.reason === "string" ? req.body.reason : void 0
+      );
+      if (!cancelled) {
+        res.status(404).json({ error: "not_found", message: "Task not found or not cancellable" });
+        return;
+      }
+      res.json({ cancelled: true });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async approveTask(req, res, next) {
+    try {
+      const approvedBy = typeof req.body?.approvedBy === "string" ? req.body.approvedBy : "human";
+      const approvalToken = typeof req.body?.approvalToken === "string" ? req.body.approvalToken : void 0;
+      const task = await this.baseline.approveTask(req.params.id, approvedBy, approvalToken);
+      res.json({ task });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("not found")) {
+        res.status(404).json({ error: "not_found", message });
+      } else if (message.includes("not blocked")) {
+        res.status(409).json({ error: "conflict", message });
+      } else if (message.includes("token") || message.includes("expired")) {
+        res.status(403).json({ error: "forbidden", message });
+      } else {
+        next(error);
+      }
+    }
+  }
+  async getTaskArtifacts(req, res, next) {
+    try {
+      const task = this.baseline.getTask(req.params.id);
+      if (!task) {
+        res.status(404).json({ error: "not_found", message: "Task not found" });
+        return;
+      }
+      res.json({ artifacts: task.artifacts });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async getTaskAudit(req, res, next) {
+    try {
+      const taskId = req.params.id;
+      const audit = this.baseline.getAuditTrail(taskId);
+      res.json({ taskId, audit });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async getTaskEvidence(req, res, next) {
+    try {
+      const taskId = req.params.id;
+      const bundle = this.baseline.getEvidenceBundle(taskId);
+      if (!bundle.task) {
+        res.status(404).json({ error: "not_found", message: "Task not found" });
+        return;
+      }
+      res.json({ taskId, bundle });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async listWorkflows(req, res, next) {
+    try {
+      const workflows = this.baseline.listWorkflows();
+      res.json({ workflows });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async runWorkflow(req, res, next) {
+    try {
+      const handle = await this.baseline.runWorkflow(req.params.id, {
+        title: req.body.title,
+        description: req.body.description,
+        priority: req.body.priority,
+        requiredCapabilities: Array.isArray(req.body.requiredCapabilities) ? req.body.requiredCapabilities : void 0,
+        acceptanceCriteria: Array.isArray(req.body.acceptanceCriteria) ? req.body.acceptanceCriteria : void 0,
+        context: req.body.context && typeof req.body.context === "object" ? req.body.context : void 0
+      });
+      if (req.body.blocking) {
+        const result = await handle.wait(req.body.timeout);
+        res.json({ task: result });
+      } else {
+        res.status(201).json({ taskId: handle.id, status: handle.status });
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+  async getCheckpoint(req, res, next) {
+    try {
+      const checkpoint = this.baseline.loadCheckpoint(req.params.id);
+      if (!checkpoint) {
+        res.status(404).json({ error: "not_found", message: "Checkpoint not found" });
+        return;
+      }
+      res.json({ checkpoint });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async recoverCheckpoint(req, res, next) {
+    try {
+      const task = this.baseline.recoverTaskFromCheckpoint(req.params.id);
+      if (!task) {
+        res.status(404).json({ error: "not_found", message: "Checkpoint not found" });
+        return;
+      }
+      res.json({ task });
+    } catch (error) {
+      next(error);
+    }
+  }
+  // ─── Agent Handlers ────────────────────────────────────────────────────────
+  async listAgents(req, res, next) {
+    try {
+      const agents = this.baseline.listAgents();
+      res.json({ agents });
+    } catch (error) {
+      next(error);
+    }
+  }
+  // ─── Knowledge Handlers ────────────────────────────────────────────────────
+  async search(req, res, next) {
+    try {
+      const policy = req.body.policy && typeof req.body.policy === "object" ? req.body.policy : void 0;
+      const results = await this.baseline.search(req.body.query, {
+        limit: req.body.limit,
+        policy
+      });
+      res.json({ results });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async getContext(req, res, next) {
+    try {
+      const level = parseContextLevel(req.query.level);
+      const policy = parsePolicy(parseJson(req.query.policy ? String(req.query.policy) : void 0));
+      const overlayOrder = req.query.overlayOrder ? String(req.query.overlayOrder).split(",").map((v) => v.trim()).filter((v) => v === "org" || v === "repo" || v === "public") : void 0;
+      const budget = parseBudget(parseJson(req.query.budget ? String(req.query.budget) : void 0));
+      const context2 = await this.baseline.getContext(req.params.subject, level, {
+        policy,
+        overlayOrder,
+        budget
+      });
+      if (!context2) {
+        res.status(404).json({ error: "not_found", message: "Context not found" });
+        return;
+      }
+      res.json({ context: context2 });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async indexKnowledge(req, res, next) {
+    try {
+      const result = await this.baseline.index({ full: req.body.full });
+      res.json({
+        indexed: result.indexed,
+        errors: result.errors,
+        skipped: result.skipped,
+        changed: result.changed,
+        removed: result.removed,
+        message: `Indexed ${result.indexed} documents`
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  // ─── Init & Scan Handlers (GA-07, GA-08) ───────────────────────────────────
+  async initDeployment(req, res, next) {
+    try {
+      const contextPath = req.body.contextPath || process.cwd();
+      const scan = await this.scanPath(contextPath);
+      const result = await this.baseline.index({ full: false });
+      res.json({
+        initialized: true,
+        contextPath,
+        detected: scan,
+        indexed: result.indexed,
+        message: `Baseline initialized for ${contextPath}`
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async scanDeployment(req, res, next) {
+    try {
+      const contextPath = req.body.contextPath || process.cwd();
+      const detected = await this.scanPath(contextPath);
+      res.json({ contextPath, detected });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async scanPath(contextPath) {
+    const detected = {};
+    try {
+      const { existsSync, readFileSync } = await import('fs');
+      const { join } = await import('path');
+      const pkgPath = join(contextPath, "package.json");
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+        if (allDeps["@anthropic-ai/sdk"]) detected.provider = "anthropic";
+        else if (allDeps["openai"]) detected.provider = "openai";
+        if (allDeps["langchain"] || allDeps["@langchain/core"]) detected.framework = "langchain";
+        if (allDeps["@modelcontextprotocol/sdk"]) detected.mcp = true;
+        if (allDeps["bullmq"] || allDeps["@temporalio/client"]) detected.orchestration = true;
+        detected.runtime = "node";
+        detected.name = pkg.name;
+      }
+      const pyReq = join(contextPath, "requirements.txt");
+      if (existsSync(pyReq)) {
+        const reqs = readFileSync(pyReq, "utf8");
+        if (reqs.includes("anthropic")) detected.provider = "anthropic";
+        else if (reqs.includes("openai")) detected.provider = "openai";
+        if (reqs.includes("langchain")) detected.framework = "langchain";
+        detected.runtime = "python";
+      }
+    } catch {
+    }
+    return detected;
+  }
+  // ─── Memory Handlers ───────────────────────────────────────────────────────
+  async remember(req, res, next) {
+    try {
+      await this.baseline.remember(req.body.key, req.body.value, {
+        scope: req.body.scope,
+        sessionId: req.body.sessionId,
+        taskId: req.body.taskId,
+        repo: req.body.repo,
+        persona: req.body.persona,
+        ttl: req.body.ttl,
+        tags: Array.isArray(req.body.tags) ? req.body.tags : void 0
+      });
+      res.json({ stored: true });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async recall(req, res, next) {
+    try {
+      const scope = parseScope(req.query.scope);
+      const sessionId = req.query.sessionId ? String(req.query.sessionId) : void 0;
+      const taskId = req.query.taskId ? String(req.query.taskId) : void 0;
+      const repo = req.query.repo ? String(req.query.repo) : void 0;
+      const persona = req.query.persona ? String(req.query.persona) : void 0;
+      const value = await this.baseline.recall(req.params.key, {
+        scope,
+        sessionId,
+        taskId,
+        repo,
+        persona
+      });
+      if (value === void 0) {
+        res.status(404).json({ error: "not_found", message: "Key not found" });
+        return;
+      }
+      res.json({ value });
+    } catch (error) {
+      next(error);
+    }
+  }
+  // ─── Stats Handler ─────────────────────────────────────────────────────────
+  async getStats(req, res, next) {
+    try {
+      const stats = this.baseline.getStats();
+      res.json(stats);
+    } catch (error) {
+      next(error);
+    }
+  }
+  // ─── Prometheus Metrics (SIGNAL-005) ───────────────────────────────────────
+  async getMetrics(req, res, next) {
+    try {
+      const stats = this.baseline.getStats();
+      const lines = [];
+      const gauge = (name, help, value, labels) => {
+        lines.push(`# HELP ${name} ${help}`);
+        lines.push(`# TYPE ${name} gauge`);
+        lines.push(labels ? `${name}{${labels}} ${value}` : `${name} ${value}`);
+      };
+      const counter = (name, help, value, labels) => {
+        lines.push(`# HELP ${name} ${help}`);
+        lines.push(`# TYPE ${name} counter`);
+        lines.push(labels ? `${name}{${labels}} ${value}` : `${name} ${value}`);
+      };
+      gauge(
+        "baseline_uptime_seconds",
+        "Seconds since API server started",
+        Math.round((Date.now() - this.metricsCounters.serverStartTime) / 1e3)
+      );
+      const tasks = this.baseline.listTasks();
+      const tasksByStatus = tasks.reduce((acc, t) => {
+        acc[t.status] = (acc[t.status] ?? 0) + 1;
+        return acc;
+      }, {});
+      lines.push("# HELP baseline_tasks_active Current tasks by status");
+      lines.push("# TYPE baseline_tasks_active gauge");
+      for (const [status, count] of Object.entries(tasksByStatus)) {
+        lines.push(`baseline_tasks_active{status="${status}"} ${count}`);
+      }
+      lines.push("# HELP baseline_tasks_total Cumulative tasks by terminal status");
+      lines.push("# TYPE baseline_tasks_total counter");
+      for (const [status, count] of this.metricsCounters.tasksTotal) {
+        lines.push(`baseline_tasks_total{status="${status}"} ${count}`);
+      }
+      const agentStats = stats.orchestrator;
+      gauge("baseline_agents_total", "Total registered agents", agentStats.agents?.total ?? 0);
+      gauge(
+        "baseline_agents_active",
+        "Currently active agents",
+        Object.values(agentStats.agents?.byRole ?? {}).reduce((a, b) => a + b, 0)
+      );
+      const memStats = stats.memory;
+      const memTotal = (memStats.working ?? 0) + (memStats.session ?? 0) + (memStats.longTerm ?? 0) + (memStats.shared ?? 0);
+      gauge("baseline_memory_entries", "Total memory entries stored", memTotal);
+      const idxStats = stats.indexer;
+      gauge("baseline_knowledge_documents", "Documents indexed in knowledge base", idxStats.documents ?? 0);
+      gauge("baseline_knowledge_compressions", "Pre-computed compressions in index", idxStats.compressions ?? 0);
+      const cacheStats = stats.cache;
+      if (typeof cacheStats.hits === "number") {
+        counter("baseline_cache_hits_total", "Total semantic cache hits", cacheStats.hits);
+        counter("baseline_cache_misses_total", "Total semantic cache misses", cacheStats.misses ?? 0);
+        if (cacheStats.hits + (cacheStats.misses ?? 0) > 0) {
+          gauge(
+            "baseline_cache_hit_rate",
+            "Cache hit rate (0\u20131)",
+            cacheStats.hits / (cacheStats.hits + (cacheStats.misses ?? 0))
+          );
+        }
+      }
+      lines.push("# HELP baseline_http_requests_total HTTP requests by method and status");
+      lines.push("# TYPE baseline_http_requests_total counter");
+      for (const [label, count] of this.metricsCounters.requestsTotal) {
+        const [method, status] = label.split("_");
+        lines.push(`baseline_http_requests_total{method="${method}",status="${status}"} ${count}`);
+      }
+      lines.push("# HELP baseline_http_request_duration_p50_ms HTTP request duration p50 in ms");
+      lines.push("# TYPE baseline_http_request_duration_p50_ms gauge");
+      lines.push("# HELP baseline_http_request_duration_p95_ms HTTP request duration p95 in ms");
+      lines.push("# TYPE baseline_http_request_duration_p95_ms gauge");
+      for (const [method, durations] of this.metricsCounters.requestDurationMs) {
+        if (durations.length > 0) {
+          const sorted = [...durations].sort((a, b) => a - b);
+          const p50 = sorted[Math.floor(sorted.length * 0.5)];
+          const p95 = sorted[Math.floor(sorted.length * 0.95)];
+          lines.push(`baseline_http_request_duration_p50_ms{method="${method}"} ${p50}`);
+          lines.push(`baseline_http_request_duration_p95_ms{method="${method}"} ${p95}`);
+        }
+      }
+      if (this.metricsCounters.tokensByAgentRole.size > 0) {
+        lines.push("# HELP baseline_task_tokens_total Cumulative tokens used by agent role");
+        lines.push("# TYPE baseline_task_tokens_total counter");
+        for (const [role, tokens] of this.metricsCounters.tokensByAgentRole) {
+          lines.push(`baseline_task_tokens_total{role="${role}"} ${tokens}`);
+        }
+      }
+      gauge("baseline_ws_active_connections", "Currently active WebSocket connections", this.clients.size);
+      counter("baseline_ws_connections_total", "Total WebSocket connections since start", this.metricsCounters.wsConnections);
+      const rollbackTotal = this.metricsCounters.tasksTotal.get("rolledback") ?? 0;
+      counter("baseline_rollback_total", "Cumulative rollbacks since start", rollbackTotal);
+      gauge(
+        "baseline_autonomous_accuracy",
+        "Ratio of self-verified autonomous task completions to total autonomous completions (0\u20131)",
+        this.metricsCounters.autonomousAccuracy
+      );
+      if (this.costGuard) {
+        const tenantCosts = this.costGuard.getCostByTenant();
+        if (tenantCosts.length > 0) {
+          lines.push("# HELP baseline_tenant_cost_usd Estimated LLM cost in USD by tenant");
+          lines.push("# TYPE baseline_tenant_cost_usd gauge");
+          for (const tc of tenantCosts) {
+            lines.push(`baseline_tenant_cost_usd{tenant_id="${tc.tenantId}"} ${tc.totalCostUsd.toFixed(6)}`);
+          }
+        }
+      }
+      if (this.traceCurator) {
+        gauge(
+          "baseline_trace_curator_dataset_size",
+          "Number of ground-truth cases in the TraceCurator dataset",
+          this.traceCurator.getDatasetSize()
+        );
+      }
+      if (this.modelVersionRegistry) {
+        const activeProviders = this.modelVersionRegistry.listActiveProviders();
+        if (activeProviders.length > 0) {
+          lines.push("# HELP baseline_active_model_version Active model version per provider (info metric, value=1)");
+          lines.push("# TYPE baseline_active_model_version gauge");
+          for (const { provider, modelId } of activeProviders) {
+            lines.push(`baseline_active_model_version{provider="${provider}",model="${modelId}"} 1`);
+          }
+        }
+      }
+      if (this.productionEvalPipeline) {
+        const history = this.productionEvalPipeline.getHistory();
+        if (history.length > 0) {
+          const latestByModel = /* @__PURE__ */ new Map();
+          for (const entry of history) {
+            latestByModel.set(entry.modelId, entry.score);
+          }
+          lines.push("# HELP baseline_eval_score_latest Latest production eval score per model (0-100)");
+          lines.push("# TYPE baseline_eval_score_latest gauge");
+          for (const [modelId, score] of latestByModel) {
+            lines.push(`baseline_eval_score_latest{model_id="${modelId}"} ${score}`);
+          }
+        }
+      }
+      if (this.driftDetector && this.productionEvalPipeline) {
+        const history = this.productionEvalPipeline.getHistory();
+        if (history.length >= 3) {
+          const driftReport = this.driftDetector.check(history);
+          const severityNum = driftReport.severity === "critical" ? 2 : driftReport.severity === "warning" ? 1 : 0;
+          gauge(
+            "baseline_model_drift_severity",
+            "Model quality drift severity: 0=none 1=warning 2=critical",
+            severityNum
+          );
+          gauge(
+            "baseline_model_drift_delta",
+            "Score delta from rolling baseline (negative = regression)",
+            driftReport.delta
+          );
+          gauge(
+            "baseline_model_drift_baseline_score",
+            "Rolling baseline score used for drift comparison",
+            driftReport.baselineScore
+          );
+          gauge(
+            "baseline_model_drift_current_score",
+            "Current model eval score from latest run",
+            driftReport.currentScore
+          );
+          counter(
+            "baseline_model_drift_samples_analyzed",
+            "Number of eval history entries analyzed for drift",
+            driftReport.samplesAnalyzed
+          );
+        }
+      }
+      if (this.opaPolicyGate) {
+        const opaMetrics = this.opaPolicyGate.getEvalMetrics();
+        if (opaMetrics.count > 0) {
+          gauge("baseline_opa_evaluation_p50_ms", "OPA policy evaluation p50 latency in ms", opaMetrics.p50Ms);
+          gauge("baseline_opa_evaluation_p95_ms", "OPA policy evaluation p95 latency in ms", opaMetrics.p95Ms);
+          gauge("baseline_opa_evaluation_p99_ms", "OPA policy evaluation p99 latency in ms (SLO-6 target: < 500ms)", opaMetrics.p99Ms);
+          counter("baseline_opa_evaluations_total", "Total OPA policy evaluations", opaMetrics.count);
+        }
+      }
+      gauge(
+        "baseline_governance_required_approvals",
+        "Operations requiring human approval",
+        stats.governance.requireApproval
+      );
+      gauge(
+        "baseline_governance_restricted_operations",
+        "Restricted operation count",
+        stats.governance.restricted
+      );
+      res.set("Content-Type", "text/plain; version=0.0.4; charset=utf-8");
+      res.send(lines.join("\n") + "\n");
+    } catch (error) {
+      next(error);
+    }
+  }
+  /** Inject a CostGuard instance for per-tenant cost metrics (SIGNAL-052). */
+  setCostGuard(guard) {
+    this.costGuard = guard;
+  }
+  /** Inject a TraceCurator for the dataset-size gauge (SIGNAL-049). */
+  setTraceCurator(curator) {
+    this.traceCurator = curator;
+  }
+  /** Inject a ModelVersionRegistry for the active-model gauge (SIGNAL-049). */
+  setModelVersionRegistry(registry) {
+    this.modelVersionRegistry = registry;
+  }
+  /** Inject a ProductionEvalPipeline for the eval score gauge (SIGNAL-056). */
+  setProductionEvalPipeline(pipeline) {
+    this.productionEvalPipeline = pipeline;
+  }
+  /** Inject a DriftDetector for model drift metrics (SIGNAL-071). */
+  setDriftDetector(detector) {
+    this.driftDetector = detector;
+  }
+  /** Inject an OPAPolicyGate for SLO-6 latency metrics. */
+  setOPAPolicyGate(gate) {
+    this.opaPolicyGate = gate;
+  }
+  // ─── WebSocket ─────────────────────────────────────────────────────────────
+  async handleWebSocketMessage(ws, message) {
+    const parsed = parseSocketMessage(message);
+    if (!parsed) {
+      ws.send(JSON.stringify({ error: "Unknown message type" }));
+      return;
+    }
+    switch (parsed.type) {
+      case "subscribe":
+        ws.send(JSON.stringify({ type: "subscribed", taskId: parsed.taskId }));
+        break;
+      case "ping":
+        ws.send(JSON.stringify({ type: "pong", timestamp: Date.now() }));
+        break;
+      default:
+        ws.send(JSON.stringify({ error: "Unknown message type" }));
+    }
+  }
+  /**
+   * Broadcast message to all connected WebSocket clients.
+   */
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+  // ─── Error Handler ─────────────────────────────────────────────────────────
+  errorHandler(err, req, res, _next) {
+    process.stderr.write(`[baseline:api] ${req.method} ${req.path} \u2014 ${err.stack ?? err.message}
+`);
+    res.status(500).json({
+      error: "internal_error",
+      message: "An unexpected error occurred. Check server logs for details."
+    });
+  }
+  // ─── Lifecycle ─────────────────────────────────────────────────────────────
+  formatStartError(error) {
+    if (error.code === "EADDRINUSE") {
+      return new Error(
+        `Port ${this.config.port} is already in use. Stop the existing Baseline API process or choose a different port.`
+      );
+    }
+    if (error.code === "EACCES") {
+      return new Error(
+        `Insufficient permission to bind port ${this.config.port}. Try a non-privileged port (for example: 3141).`
+      );
+    }
+    return new Error(`Failed to start API server on port ${this.config.port}: ${error.message}`);
+  }
+  async start() {
+    if (this.server.listening) return;
+    return new Promise((resolve, reject) => {
+      const onError = (error) => {
+        this.server.off("listening", onListening);
+        reject(this.formatStartError(error));
+      };
+      const onListening = () => {
+        this.server.off("error", onError);
+        resolve();
+      };
+      this.server.once("error", onError);
+      this.server.once("listening", onListening);
+      this.server.listen(this.config.port);
+    });
+  }
+  async stop() {
+    this.wss.close();
+    if (!this.server.listening) return;
+    return new Promise((resolve, reject) => {
+      this.server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+};
+/**
+ * BaselineOS OpenTelemetry — SIGNAL-012
+ *
+ * Distributed tracing for the multi-agent orchestration layer.
+ * Initializes the OTel Node SDK and exports a shared tracer.
+ *
+ * Spans emitted:
+ *   task.execute          root span per executeTask() call
+ *   task.policy.pre       OPA pre-execution gate
+ *   task.policy.post      OPA post-execution gate
+ *   task.perform          performExecution() step loop
+ *   task.self_verify      selfVerify() LLM call
+ *   task.review           conductReview() LLM call
+ *
+ * Trace context is propagated through AgentBus messages via the
+ * optional `traceContext` field (W3C traceparent format).
+ *
+ * Configuration:
+ *   OTEL_EXPORTER_OTLP_ENDPOINT  OTLP HTTP collector (default: http://localhost:4318)
+ *   OTEL_SERVICE_NAME            service name override (default: baselineos)
+ *   BASELINE_OTEL_DISABLED       set to '1' to disable entirely (e.g. in tests)
+ *
+ * @license Apache-2.0
+ */
+/**
+ * BaselineOS API Server
+ * 
+ * REST API and WebSocket for programmatic access.
+ * 
+ * @license Apache-2.0
+ */
+
+export { APIServer };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map