vibeostheog 0.19.1 → 0.19.3

package/.opencode/plugins/vibeOS-tui.tsx

@@ -0,0 +1,340 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui"
+import { createSignal } from "solid-js"
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { homedir } from "node:os"
+
+const DEFAULT_PORT = 9578
+const TIERS_FILE = join(homedir(), ".claude/model-tiers.json")
+
+function getBaseUrl() {
+  try {
+    if (existsSync(TIERS_FILE)) {
+      const tiers = JSON.parse(readFileSync(TIERS_FILE, "utf-8"))
+      const port = Number(tiers?.selection?.mcp_port)
+      if (Number.isFinite(port) && port > 0) return `http://localhost:${port}`
+    }
+  } catch {}
+  return `http://localhost:${DEFAULT_PORT}`
+}
+
+type StatusResponse = {
+  todos: {
+    total: number
+    pending: number
+  }
+
+  enabled: boolean
+  active_slot: string
+  enforce: boolean
+  flow_enforcer: boolean
+  flow_extract_todos: boolean
+  tdd_enforcer: boolean
+  tdd_strict: boolean
+  thinking: string
+  current_model: string
+  credit_percent: number
+  version: string
+  backend_connected?: boolean
+  backend_health_url?: string | null
+  model_locked?: boolean
+  locked_slot?: string | null
+  locked_model?: string | null
+}
+
+type SavingsResponse = {
+  lifetime: {
+    delegation_usd: number
+    cache_usd: number
+    missed_context7_usd: number
+    total_warns: number
+  }
+  current_session: {
+    delegation_usd: number
+    cache_usd: number
+    warns_count: number
+    tool_breakdown: Record<string, number>
+  }
+  cache_hits_this_session: number
+  trend: string
+  savings_rate_per_hour: number
+}
+
+// Named export for TUI auto-discovery
+export const vibeOSTui = async (api, _options, _meta) => {
+  try {
+    if (api?.ui?.toast) {
+      api.ui.toast({ variant: "info", message: "vibeOS TUI plugin executing" })
+    }
+    if (typeof process !== "undefined") {
+      process.stderr?.write?.("[vibeOS-tui] plugin function called\n")
+    }
+  } catch (e) {
+    if (typeof process !== "undefined") {
+      process.stderr?.write?.("[vibeOS-tui] ERROR: " + String(e) + "\n")
+    }
+  }
+}
+
+const plugin: TuiPlugin = async (api, _options, _meta) => {
+  const [status, setStatus] = createSignal<StatusResponse | null>(null)
+  const [savings, setSavings] = createSignal<SavingsResponse | null>(null)
+  const [error, setError] = createSignal<string | null>(null)
+
+  const poll = async () => {
+    try {
+      const baseUrl = getBaseUrl()
+      const [s, sa] = await Promise.all([
+        fetch(`${baseUrl}/status`).then((r) => r.json()),
+        fetch(`${baseUrl}/savings`).then((r) => r.json()),
+      ])
+      setStatus(s)
+      setSavings(sa)
+      setError(null)
+    } catch {
+      setError("vibeOS MCP offline")
+    }
+  }
+
+  await poll()
+  const timer = setInterval(poll, 3000)
+
+  api.lifecycle.onDispose(() => {
+    clearInterval(timer)
+  })
+
+  const doAction = async (body: Record<string, unknown>) => {
+    try {
+      const res = await fetch(`${getBaseUrl()}/trinity`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      })
+      const data = await res.json()
+      if (data.ok) {
+        api.ui.toast({ variant: "success", message: data.result })
+        await poll()
+      } else {
+        api.ui.toast({ variant: "error", message: "Action failed" })
+      }
+    } catch {
+      api.ui.toast({ variant: "error", message: "vibeOS offline" })
+    }
+  }
+
+  const Slot = api.ui.Slot
+
+  api.slots.register((props: { session_id: string }) => {
+    const s = status()
+    const sv = savings()
+
+    if (error()) {
+      return (
+        <box flexDirection="column">
+          <Slot name="sidebar_title" session_id={props.session_id} title="vibeOS">
+            <text dim>vibeOS offline</text>
+          </Slot>
+          <Slot name="sidebar_content" session_id={props.session_id}>
+            <box flexDirection="column" padding={1}>
+              <text dim>vibeOS MCP not running</text>
+              <newline />
+              <text dim>ensure the server plugin is active</text>
+            </box>
+          </Slot>
+          <Slot name="sidebar_footer" session_id={props.session_id}>
+            <text dim>vibeOS MCP offline</text>
+          </Slot>
+        </box>
+      )
+    }
+
+    const activeSlot = s?.active_slot ?? "?"
+    const enabled = s?.enabled ?? false
+    const trendArrow = sv?.trend === "up" ? "^" : sv?.trend === "down" ? "v" : "-"
+    const delegation = (sv?.current_session?.delegation_usd ?? 0) + (sv?.lifetime?.delegation_usd ?? 0)
+    const cache = (sv?.current_session?.cache_usd ?? 0) + (sv?.lifetime?.cache_usd ?? 0)
+    const lifetime = (sv?.lifetime?.delegation_usd ?? 0) + (sv?.lifetime?.cache_usd ?? 0)
+    const missedC7 = sv?.lifetime?.missed_context7_usd ?? 0
+    const toolBreakdown = sv?.current_session?.tool_breakdown ?? {}
+    const topTools = Object.entries(toolBreakdown)
+      .sort(([, a], [, b]) => (b as number) - (a as number))
+      .slice(0, 5)
+    const trendColor = sv?.trend === "up" ? "green" : sv?.trend === "down" ? "red" : "yellow"
+    const shortModel = s?.current_model?.split("/")[1] ?? s?.current_model ?? "?"
+    const flowOn = s?.flow_enforcer ?? false
+    const tddOn = s?.tdd_enforcer ?? false
+    const backendConnected = s?.backend_connected ?? false
+    const lockLabel = s?.model_locked
+      ? `${s?.locked_slot ? `${s.locked_slot} ` : ""}${s?.locked_model ?? ""}`.trim()
+      : "off"
+
+    return (
+      <box flexDirection="column">
+        <Slot name="sidebar_title" session_id={props.session_id} title="vibeOS">
+          <box>
+            <text bold>vibeOS</text>
+            <text dim> | </text>
+            <text color={enabled ? "green" : "red"} bold>{activeSlot}</text>
+            <text> </text>
+            <text color={enabled ? "green" : "red"}>{enabled ? "." : "o"}</text>
+          </box>
+        </Slot>
+        <Slot name="sidebar_content" session_id={props.session_id}>
+          <box flexDirection="column" padding={1}>
+            <text dim bold>MODEL STATUS</text>
+            <newline />
+            <box>
+              <text bold={activeSlot === "brain"} color={activeSlot === "brain" ? "green" : undefined}>
+                {shortModel}
+              </text>
+              {activeSlot === "brain" && <text color="green"> active</text>}
+            </box>
+            <newline />
+            <box>
+              <text>Backend </text>
+              <text color={backendConnected ? "green" : "red"} bold>{backendConnected ? "ON" : "OFF"}</text>
+            </box>
+            <newline />
+            <box>
+              <text>Lock </text>
+              <text color={s?.model_locked ? "green" : "red"} bold>{s?.model_locked ? "ON" : "OFF"}</text>
+              {s?.model_locked && lockLabel && <text dim> {lockLabel}</text>}
+            </box>
+            <newline />
+            <text dim>---</text>
+            <newline />
+            <box>
+              <text>Flow </text>
+              <text color={flowOn ? "green" : "red"} bold>{flowOn ? "ON" : "OFF"}</text>
+            </box>
+            <newline />
+            <box>
+              <text>TDD </text>
+              <text color={tddOn ? "green" : "red"} bold>{tddOn ? "ON" : "OFF"}</text>
+              {tddOn && s?.tdd_strict && <text dim> strict</text>}
+            </box>
+            <newline />
+            <box>
+              <text>Enforce </text>
+              <text color={s?.enforce ? "green" : "red"} bold>{s?.enforce ? "ON" : "OFF"}</text>
+            </box>
+            <newline />
+            <text dim>---</text>
+            <newline />
+            <box>
+              <text>Thinking: </text>
+              <text>{s?.thinking ?? "?"}</text>
+            </box>
+            <newline />
+            <newline />
+            <text dim bold>SAVINGS</text>
+            <newline />
+            <box>
+              <text bold>Saved: </text>
+              <text bold color={trendColor}>${lifetime.toFixed(2)} {trendArrow}</text>
+            </box>
+            <newline />
+            <box><text>  Delegation: </text><text>${delegation.toFixed(2)}</text></box>
+            <newline />
+            <box><text>  Cache: </text><text>${cache.toFixed(2)}</text></box>
+            <newline />
+            <box><text>  C7 missed: </text><text>${missedC7.toFixed(2)}</text></box>
+            <newline />
+            <text dim>---</text>
+            <newline />
+            <box><text>Rate: </text><text>${sv?.savings_rate_per_hour?.toFixed(2) ?? "0.00"}/hr</text></box>
+            <newline />
+            <box><text>Warns: </text><text>{sv?.current_session?.warns_count ?? 0}</text></box>
+            <newline />
+            <text dim>---</text>
+            <newline />
+            <text dim>Tool split:</text>
+            <newline />
+            {topTools.map(([tool, val]) => (
+            <newline />
+            <text dim bold>TODOS</text>
+            <newline />
+            <box>
+              <text>Pending: </text>
+              <text color={s?.todos?.pending > 0 ? "yellow" : "green"} bold>
+                {s?.todos?.pending ?? 0}
+              </text>
+              <text> / {s?.todos?.total ?? 0}</text>
+            </box>
+            <newline />
+
+              <>
+                <box>
+                  <text>  {tool.padEnd(8)}</text>
+                  <text>${(val as number).toFixed(2)}</text>
+                </box>
+                <newline />
+              </>
+            ))}
+            <newline />
+            <text dim bold>CONTROLS</text>
+            <newline />
+            <box>
+              <text
+                onClick={() => doAction({ action: "set", slot: "brain", level: null })}
+                color={activeSlot === "brain" ? "green" : "dim"}
+                bold={activeSlot === "brain"}
+              >[brain]</text>
+              <text> </text>
+              <text
+                onClick={() => doAction({ action: "set", slot: "medium", level: null })}
+                color={activeSlot === "medium" ? "green" : "dim"}
+                bold={activeSlot === "medium"}
+              >[medium]</text>
+              <text> </text>
+              <text
+                onClick={() => doAction({ action: "set", slot: "cheap", level: null })}
+                color={activeSlot === "cheap" ? "green" : "dim"}
+                bold={activeSlot === "cheap"}
+              >[cheap]</text>
+            </box>
+            <newline />
+            <box>
+              <text
+                onClick={() => doAction({ action: "flow", slot: flowOn ? "off" : "on", level: null })}
+                color={flowOn ? "green" : "red"} bold
+              >[Flow {flowOn ? "ON" : "OFF"}]</text>
+            </box>
+            <newline />
+            <box>
+              <text
+                onClick={() => doAction({ action: "tdd", slot: tddOn ? "off" : "on", level: null })}
+                color={tddOn ? "green" : "red"} bold
+              >[TDD {tddOn ? "ON" : "OFF"}]</text>
+            </box>
+            <newline />
+            <box>
+              <text
+                onClick={() => doAction({ action: "enforce", slot: s?.enforce ? "off" : "on", level: null })}
+                color={s?.enforce ? "green" : "red"} bold
+              >[Enforce {s?.enforce ? "ON" : "OFF"}]</text>
+            </box>
+            <newline />
+            <box>
+              <text
+                onClick={() => doAction({ action: "disable", slot: null, level: null })}
+                color="red" bold
+              >[Disable]</text>
+            </box>
+          </box>
+        </Slot>
+        <Slot name="sidebar_footer" session_id={props.session_id}>
+          <box>
+            <text dim>Saved </text>
+            <text color={trendColor}>{lifetime.toFixed(2)}</text>
+            <text dim> {trendArrow} </text>
+            <text>{sv?.savings_rate_per_hour?.toFixed(2) ?? "0.00"}/hr</text>
+            <text dim> | {sv?.current_session?.warns_count ?? 0} warns</text>
+          </box>
+        </Slot>
+      </box>
+    )
+  })
+}
+
+export default { tui: plugin }

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.19.3
+- fix: auto-register vibeOS plugin in opencode.json during deploy
+
+
+## 0.19.2
+- fix: export server and tui entrypoints
+
 ## 0.19.1
 - fix: make README and runtime self-contained
 - test: add 59 integration + e2e tests for cross-module behavior and user workflows

package/README.md

@@ -48,6 +48,8 @@ If you keep a local checkout of the plugin, point OpenCode at the built file ins
 
 Restart OpenCode Desktop after changing the config.
 
+The package also exposes `vibeostheog/server` and `vibeostheog/tui` for integrations that need the MCP server or sidebar plugin entrypoints directly.
+
 ## Common Npm Commands
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeostheog",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "description": "Cost-aware delegation enforcer for OpenCode. Tracks model usage, routes Task subagents to cheaper tiers, surfaces cumulative savings in chat. Includes research audit, reporting framework, project memory, progressive scratchpad decadence, and trinity CLI for brain/medium/cheap slot switching.",
   "scripts": {
     "release": "node scripts/release.mjs",
@@ -22,11 +22,13 @@
     "precommit": "node scripts/pre-commit.mjs",
     "audit-state": "node scripts/audit-state.mjs",
     "migrate-ledger": "node scripts/migrate-ledger.mjs",
-    "postinstall": "node scripts/deploy.mjs 2>/dev/null || true"
+    "postinstall": "node scripts/deploy.mjs"
   },
   "type": "module",
   "exports": {
-    ".": "./src/index.js"
+    ".": "./src/index.js",
+    "./server": "./src/lib/vibeos-mcp-server.js",
+    "./tui": "./.opencode/plugins/vibeOS-tui.tsx"
   },
   "keywords": [
     "opencode",
@@ -46,6 +48,8 @@
   },
   "files": [
     "src/index.js",
+    "src/lib/vibeos-mcp-server.js",
+    ".opencode/plugins/vibeOS-tui.tsx",
     "scripts/deploy.mjs",
     "model-tiers.sample.json",
     "README.md",

package/scripts/deploy.mjs

@@ -110,6 +110,30 @@ try {
     process.stderr.write("[vibeOS deploy]   Or install via WSL and use crontab there.\n")
   }
 
+  // Auto-register in opencode.json so OpenCode loads the plugin
+  try {
+    const ocConfigPath = join(homedir(), ".config", "opencode", "opencode.json")
+    if (existsSync(ocConfigPath)) {
+      const raw = readFileSync(ocConfigPath, "utf-8")
+      let config = {}
+      try {
+        const cleaned = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "")
+        config = JSON.parse(cleaned)
+      } catch {
+        config = {}
+      }
+      if (!Array.isArray(config.plugin)) config.plugin = []
+      const hasVibeOs = config.plugin.some(p => typeof p === "string" && p.includes("vibeOS"))
+      if (!hasVibeOs) {
+        config.plugin.push("./plugins/vibeOS.js")
+        writeFileSync(ocConfigPath, JSON.stringify(config, null, 2) + "\n")
+        process.stderr.write("[vibeOS deploy] Registered vibeOS in opencode.json\n")
+      }
+    }
+  } catch {
+    process.stderr.write("[vibeOS deploy] Could not auto-register in opencode.json (plugin may need manual config)\n")
+  }
+
   process.stderr.write("[vibeOS deploy] Done\n")
 } catch (e) {
   process.stderr.write(`[vibeOS deploy] ERROR: ${e.message}\n`)

package/src/index.js

@@ -545,7 +545,7 @@ function computeSessionMetrics(state, sessionId) {
   };
 }
 
-// src/lib/vibeos-mcp-server.ts
+// src/lib/vibeos-mcp-server.js
 import http from "node:http";
 import { parse as parseUrl } from "node:url";
 import { createReadStream, existsSync as existsSync2, statSync as statSync2 } from "node:fs";
@@ -594,7 +594,8 @@ function resolveDashboardDir() {
     join2(_MCP_DIR, "dashboard", "dist")
   ];
   for (const p of c) {
-    if (existsSync2(join2(p, "index.html"))) return p;
+    if (existsSync2(join2(p, "index.html")))
+      return p;
   }
   return c[0];
 }
@@ -820,8 +821,10 @@ function createMcpServer(deps) {
   };
   return {
     async start(port) {
-      if (server2) return server2;
-      if (startPromise) return startPromise;
+      if (server2)
+        return server2;
+      if (startPromise)
+        return startPromise;
       startPromise = new Promise((resolve, reject) => {
         const srv = http.createServer((req, res) => {
           void handler(req, res);
@@ -839,8 +842,10 @@ function createMcpServer(deps) {
       }
     },
     async close() {
-      if (!server2) return;
-      if (closePromise) return closePromise;
+      if (!server2)
+        return;
+      if (closePromise)
+        return closePromise;
       closePromise = new Promise((resolve, reject) => {
         server2?.close((err) => err ? reject(err) : resolve());
       });

package/src/lib/vibeos-mcp-server.js

@@ -0,0 +1,320 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 vibeOS <https://github.com/DrunkkToys/vibeOS>
+import http from "node:http";
+import { parse as parseUrl } from "node:url";
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { extname, join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const MIME_MAP = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+};
+function json(res, statusCode, data) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(data));
+}
+function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let raw = "";
+        req.on("data", (chunk) => {
+            raw += String(chunk || "");
+            if (raw.length > 1024 * 1024) {
+                reject(new Error("payload too large"));
+            }
+        });
+        req.on("end", () => {
+            if (!raw.trim()) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error("invalid request"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+const _MCP_FILENAME = fileURLToPath(import.meta.url);
+const _MCP_DIR = dirname(_MCP_FILENAME);
+function resolveDashboardDir() {
+    const c = [
+        join(_MCP_DIR, "dashboard", "dist"),
+    ];
+    for (const p of c) {
+        if (existsSync(join(p, "index.html")))
+            return p;
+    }
+    return c[0];
+}
+const DASHBOARD_DIR = resolveDashboardDir();
+const BACKEND_HEALTH_URL = process.env.VIBEOS_BACKEND_HEALTH_URL || "http://127.0.0.1:3000/health";
+const BACKEND_HEALTH_TTL_MS = 5_000;
+let backendHealth = { ok: null, checkedAt: 0 };
+async function probeBackendHealth(force = false) {
+    const now = Date.now();
+    if (!force && backendHealth.ok !== null && (now - backendHealth.checkedAt) < BACKEND_HEALTH_TTL_MS) {
+        return backendHealth.ok;
+    }
+    try {
+        const ctl = new AbortController();
+        const timer = setTimeout(() => ctl.abort(), 1500);
+        const res = await fetch(BACKEND_HEALTH_URL, { signal: ctl.signal });
+        clearTimeout(timer);
+        backendHealth = { ok: res.ok, checkedAt: now };
+        return res.ok;
+    }
+    catch {
+        backendHealth = { ok: false, checkedAt: now };
+        return false;
+    }
+}
+function sendFile(res, fp) {
+    if (!existsSync(fp)) {
+        res.statusCode = 404;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("not found");
+        return;
+    }
+    const ext = extname(fp).toLowerCase();
+    const mime = MIME_MAP[ext] || "application/octet-stream";
+    const st = statSync(fp);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", mime);
+    res.setHeader("Content-Length", st.size);
+    res.setHeader("Cache-Control", "no-cache");
+    const s = createReadStream(fp);
+    s.pipe(res);
+    s.on("error", () => { res.statusCode = 500; res.end(); });
+}
+function serveDashboard(res, p) {
+    const idx = join(DASHBOARD_DIR, "index.html");
+    let fp = join(DASHBOARD_DIR, p === "/" ? "index.html" : p);
+    if (existsSync(fp) && statSync(fp).isFile()) {
+        sendFile(res, fp);
+        return;
+    }
+    if (existsSync(idx)) {
+        sendFile(res, idx);
+        return;
+    }
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("not found");
+}
+export function createMcpServer(deps) {
+    let server = null;
+    let startPromise = null;
+    let closePromise = null;
+    const handler = async (req, res) => {
+        try {
+            const method = (req.method || "GET").toUpperCase();
+            const parsed = parseUrl(req.url || "/", true);
+            const path = parsed.pathname || "/";
+            if (method === "GET" && path === "/status") {
+                const state = deps.getState();
+                const ok = await probeBackendHealth();
+                json(res, 200, { ...state, backend_connected: ok === true, backend_health_url: BACKEND_HEALTH_URL });
+                return;
+            }
+            if (method === "GET" && path === "/savings") {
+                json(res, 200, deps.getSavings());
+                return;
+            }
+            if (method === "GET" && path === "/todos") {
+                json(res, 200, deps.getTodos());
+                return;
+            }
+            if (method === "GET" && path === "/sessions") {
+                const state = deps.getState();
+                const sessionsMap = state?.sessions_raw || {};
+                const sessions = Object.entries(sessionsMap).map(([id, ses]) => ({
+                    id,
+                    started: ses?.started || null,
+                    cost_usd: Number(ses?.cost_usd ?? 0) || 0,
+                    delegation_savings_usd: Array.isArray(ses?.warns)
+                        ? ses.warns.reduce((sum, w) => sum + (Number(w?.est_savings_usd ?? 0) || 0), 0)
+                        : ses?.total_savings_usd || 0,
+                    cache_savings_usd: Number(ses?.cache_savings_usd ?? 0) || 0,
+                    warns_count: Array.isArray(ses?.warns) ? ses.warns.length : 0,
+                }));
+                json(res, 200, { sessions, total_sessions: sessions.length });
+                return;
+            }
+            if (method === "GET" && path === "/sessions/current") {
+                json(res, 200, deps.getSessionMetrics(deps.getCurrentSessionId()));
+                return;
+            }
+            if (method === "GET" && path === "/reports") {
+                try {
+                    const query = parsed.query;
+                    const type = typeof query.type === "string" ? query.type : undefined;
+                    const project = typeof query.project === "string" ? query.project : undefined;
+                    const hoursRaw = query.hours;
+                    const hours = hoursRaw != null ? Number(hoursRaw) : undefined;
+                    const fingerprint = typeof query.fingerprint === "string" ? query.fingerprint : undefined;
+                    const reports = deps.listReports({ type, project, hours: Number.isFinite(hours) ? hours : undefined, fingerprint });
+                    json(res, 200, reports);
+                }
+                catch (err) {
+                    const error = err;
+                    if (error?.status === 404) {
+                        json(res, 404, { error: "not found", status: 404 });
+                        return;
+                    }
+                    throw err;
+                }
+                return;
+            }
+            if (method === "GET" && path.startsWith("/reports/")) {
+                const id = decodeURIComponent(path.replace(/^\/reports\//, "")).trim();
+                const report = deps.readReport(id);
+                if (!report) {
+                    json(res, 404, { error: "not found", status: 404 });
+                    return;
+                }
+                json(res, 200, report);
+                return;
+            }
+            if (method === "GET" && path === "/diagnose") {
+                json(res, 200, deps.runDiagnose());
+                return;
+            }
+            if (method === "GET" && path === "/project") {
+                json(res, 200, deps.runProject());
+                return;
+            }
+            if (method === "POST" && path === "/trinity") {
+                let body;
+                try {
+                    body = await parseBody(req);
+                }
+                catch {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const action = body?.action;
+                const slot = body?.slot;
+                const level = body?.level;
+                if (!action || typeof action !== "string") {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const result = await deps.runTrinity(action, { slot, level });
+                const txt = typeof result === "string" ? result : JSON.stringify(result);
+                const ok = !(txt.startsWith("❌") || txt.toLowerCase().includes("unknown action"));
+                json(res, ok ? 200 : 400, ok ? { ok: true, result } : { ok: false, error: txt });
+                return;
+            }
+            if (method === "POST" && path === "/research-audit") {
+                let body;
+                try {
+                    body = await parseBody(req);
+                }
+                catch {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const hours = Number(body?.hours ?? 24);
+                const report = deps.runResearchAudit(Number.isFinite(hours) ? hours : 24);
+                json(res, 200, report);
+                return;
+            }
+            if (method === "POST" && path === "/reports") {
+                let body;
+                try {
+                    body = await parseBody(req);
+                }
+                catch {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                if (!body || typeof body !== "object") {
+                    json(res, 400, { error: "invalid request", status: 400 });
+                    return;
+                }
+                const id = deps.saveReport({
+                    type: "manual",
+                    summary: body.summary || "",
+                    findings: body.findings || [],
+                    metrics: body.metrics || {},
+                    narrative: body.narrative || "",
+                    tags: Array.isArray(body.tags) ? body.tags : [],
+                });
+                if (!id) {
+                    json(res, 500, { error: "failed to save report", status: 500 });
+                    return;
+                }
+                json(res, 200, { ok: true, id });
+                return;
+            }
+            if (method === "POST" && path === "/sessions/checkout") {
+                const result = deps.generateSessionCheckout();
+                json(res, 200, result);
+                return;
+            }
+            if (method === "GET" && path === "/") {
+                serveDashboard(res, "/");
+                return;
+            }
+            if (method === "GET" && (path.startsWith("/assets/") || path.startsWith("/favicon") || path.endsWith(".js") || path.endsWith(".css") || path.endsWith(".html"))) {
+                serveDashboard(res, path);
+                return;
+            }
+            if (method === "GET" && path === "/health") {
+                json(res, 200, { ok: true });
+                return;
+            }
+            json(res, 404, { error: "not found", status: 404 });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "server error";
+            json(res, 500, { error: message, status: 500 });
+        }
+    };
+    return {
+        async start(port) {
+            if (server)
+                return server;
+            if (startPromise)
+                return startPromise;
+            startPromise = new Promise((resolve, reject) => {
+                const srv = http.createServer((req, res) => { void handler(req, res); });
+                srv.once("error", reject);
+                srv.listen(port, () => {
+                    server = srv;
+                    resolve(srv);
+                });
+            });
+            try {
+                return await startPromise;
+            }
+            finally {
+                startPromise = null;
+            }
+        },
+        async close() {
+            if (!server)
+                return;
+            if (closePromise)
+                return closePromise;
+            closePromise = new Promise((resolve, reject) => {
+                server?.close(err => err ? reject(err) : resolve());
+            });
+            try {
+                await closePromise;
+            }
+            finally {
+                server = null;
+                closePromise = null;
+            }
+        },
+    };
+}