@jmanuelcorral/openteam 0.1.15 → 0.1.17

package/dist/index.js

@@ -25,6 +25,24 @@ var PrivacyModeSchema = z.enum([
   "off"
 ]);
 var BaselineModeSchema = z.enum(["auto", "pinned"]);
+var DashboardHostSchema = z.enum(["127.0.0.1", "localhost"]);
+var DashboardConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  host: DashboardHostSchema.default("127.0.0.1"),
+  port: z.number().int().min(1024).max(65535).default(4599),
+  autoPortFallback: z.boolean().default(true),
+  refreshMs: z.number().int().min(250).default(2000),
+  recentRoutes: z.number().int().positive().default(50),
+  openBrowser: z.boolean().default(false)
+}).default({
+  enabled: false,
+  host: "127.0.0.1",
+  port: 4599,
+  autoPortFallback: true,
+  refreshMs: 2000,
+  recentRoutes: 50,
+  openBrowser: false
+});
 var defaultLocalModel = {
   providerID: "ollama",
   modelID: "qwen3:8b"
@@ -86,7 +104,8 @@ var OpenTeamConfigSchema = z.object({
     frontierTokensPerSession: z.number().int().positive().optional(),
     hardStopOnBudgetExhaustion: z.boolean().default(false)
   }).default({ hardStopOnBudgetExhaustion: false }),
-  privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive")
+  privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
+  dashboard: DashboardConfigSchema
 });
 
 // src/config/persist.ts
@@ -948,6 +967,32 @@ function autoBaseline(config) {
   };
 }
 
+// src/commands/dashboard.ts
+function renderDashboardStatus(dashboard) {
+  const url = `http://${dashboard.host}:${dashboard.port}`;
+  if (!dashboard.enabled) {
+    return [
+      "Dashboard: deshabilitado.",
+      "",
+      'Para activarlo, pon "dashboard": { "enabled": true } en .opencode/openteam.json',
+      "y recarga opencode. Se servirá (loopback) en:",
+      `  ${url}`
+    ].join(`
+`);
+  }
+  return [
+    "Dashboard: habilitado.",
+    `  URL:        ${url}`,
+    `  Refresco:   ${dashboard.refreshMs} ms (SSE + polling)`,
+    `  Rutas:      últimas ${dashboard.recentRoutes}`,
+    dashboard.autoPortFallback ? "  Puerto:     con fallback automático si está ocupado" : "  Puerto:     fijo (sin fallback)",
+    "",
+    "Nota: solo escucha en loopback y nunca expone prompts (solo hashes).",
+    "El servidor corre dentro de la sesión de opencode; se cierra al salir."
+  ].join(`
+`);
+}
+
 // src/commands/doctor.ts
 function runtimeLine(snapshot) {
   const mark = snapshot.reachable ? "✓" : "✗";
@@ -1097,6 +1142,7 @@ var HELP = [
   "  openteam baseline auto            Baseline cheapest-capable (modo auto)",
   "  openteam doctor                   Diagnóstico de runtimes y config",
   "  openteam agents                   Lista los agentes y el LLM (local/frontier) de cada uno",
+  "  openteam dashboard                Estado y URL del dashboard web (loopback)",
   "  openteam report                   Resumen de coste/ahorro (telemetría)",
   "  openteam yolo status              Muestra si el modo YOLO está activo",
   "  openteam yolo on                  Activa YOLO (opencode auto-aprueba todo)",
@@ -1286,6 +1332,10 @@ async function runCli(argv, deps) {
     if (command === "agents") {
       return await runAgents(deps, configPath, opencodeConfigPath);
     }
+    if (command === "dashboard") {
+      const config = await deps.loadConfig(configPath);
+      return { exitCode: 0, stdout: renderDashboardStatus(config.dashboard) };
+    }
     if (command === undefined || command === "help" || command === "--help") {
       return { exitCode: 0, stdout: HELP };
     }
@@ -1316,13 +1366,23 @@ function commandArgv(action, model) {
       return ["report"];
     case "agents":
       return ["agents"];
+    case "dashboard":
+      return ["dashboard"];
   }
 }
 function createCommandTool(deps) {
   return tool({
-    description: "Comandos runtime de openteam: baseline (show/set/auto), doctor, report y agents (LLM por agente: local/frontier + suscripción).",
+    description: "Comandos runtime de openteam: baseline (show/set/auto), doctor, report, agents (LLM por agente: local/frontier + suscripción) y dashboard (estado/URL del panel web).",
     args: {
-      action: tool.schema.enum(["show", "set", "auto", "doctor", "report", "agents"]).describe("Acción a ejecutar"),
+      action: tool.schema.enum([
+        "show",
+        "set",
+        "auto",
+        "doctor",
+        "report",
+        "agents",
+        "dashboard"
+      ]).describe("Acción a ejecutar"),
       model: tool.schema.string().optional().describe("Modelo provider/model (solo para action=set)")
     },
     async execute(args) {
@@ -1965,6 +2025,579 @@ async function readCostRecords(path, deps = {}) {
   }
 }
 
+// src/web/paths.ts
+var DEFAULT_BACKLOG_PATH = ".opencode/openteam-backlog.md";
+
+// src/web/start.ts
+import { watch as fsWatch } from "node:fs";
+
+// src/web/activity.ts
+function createActivityBuffer(max = 100) {
+  const entries = [];
+  return {
+    push(entry) {
+      entries.push(entry);
+      if (entries.length > max) {
+        entries.splice(0, entries.length - max);
+      }
+    },
+    list() {
+      return [...entries];
+    }
+  };
+}
+
+// src/dashboard/render.ts
+var TIERS2 = [
+  "trivial",
+  "simple",
+  "moderate",
+  "hard"
+];
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function usd2(value) {
+  return `$${value.toFixed(5)}`;
+}
+function pct(value) {
+  return `${value.toFixed(2)}%`;
+}
+function agentModel(agent) {
+  return agent.model === undefined ? "hereda default" : `${agent.model.providerID}/${agent.model.modelID}`;
+}
+function summaryPanel(cost) {
+  return [
+    '<section class="panel" id="panel-summary">',
+    "<h2>Resumen de routing</h2>",
+    '<div class="grid">',
+    `<div class="stat"><span class="k">Decisiones</span><span class="v">${cost.count}</span></div>`,
+    `<div class="stat"><span class="k">Local</span><span class="v">${cost.localCount}</span></div>`,
+    `<div class="stat"><span class="k">Frontier</span><span class="v">${cost.frontierCount}</span></div>`,
+    `<div class="stat"><span class="k">Coste real</span><span class="v">${usd2(cost.totalEstimatedUSD)}</span></div>`,
+    `<div class="stat"><span class="k">Baseline</span><span class="v">${usd2(cost.totalBaselineUSD)}</span></div>`,
+    `<div class="stat"><span class="k">Ahorro</span><span class="v good">${usd2(cost.totalSavingsUSD)} (${pct(cost.savingsPct)})</span></div>`,
+    `<div class="stat"><span class="k">Tokens in</span><span class="v">${cost.tokensIn}</span></div>`,
+    `<div class="stat"><span class="k">Tokens out</span><span class="v">${cost.tokensOut}</span></div>`,
+    "</div>",
+    "</section>"
+  ].join("");
+}
+function tierPanel(cost) {
+  const rows = TIERS2.map((tier) => {
+    const summary = cost.byTier[tier];
+    return `<tr><td>${tier}</td><td>${summary.count}</td><td>${usd2(summary.estimatedUSD)}</td><td class="good">${usd2(summary.savingsUSD)}</td></tr>`;
+  }).join("");
+  return [
+    '<section class="panel" id="panel-tier">',
+    "<h2>Por tier</h2>",
+    "<table><thead><tr><th>Tier</th><th>Nº</th><th>Coste</th><th>Ahorro</th></tr></thead>",
+    `<tbody>${rows}</tbody></table>`,
+    "</section>"
+  ].join("");
+}
+function loopItemRow(item) {
+  const box = item.done ? "☑" : "☐";
+  const cls = item.done ? "done" : "open";
+  const who = item.assignee === undefined ? "" : `<span class="who">@${escapeHtml(item.assignee)}</span> `;
+  return `<li class="${cls}"><span class="box">${box}</span> ${who}${escapeHtml(item.text)}</li>`;
+}
+function loopPanel(loop) {
+  if (loop === undefined) {
+    return [
+      '<section class="panel" id="panel-loop">',
+      "<h2>Loop</h2>",
+      '<p class="muted">Sin backlog activo (no hay <code>openteam-backlog.md</code>).</p>',
+      "</section>"
+    ].join("");
+  }
+  const items = loop.items.map(loopItemRow).join("");
+  const commit = loop.lastCommit === undefined ? "" : `<p class="muted">Último commit: <code>${escapeHtml(loop.lastCommit.hash)}</code> ${escapeHtml(loop.lastCommit.subject)}</p>`;
+  return [
+    '<section class="panel" id="panel-loop">',
+    "<h2>Loop</h2>",
+    `<div class="progress" role="progressbar" aria-valuenow="${loop.progressPct}" aria-valuemin="0" aria-valuemax="100"><div class="bar" style="width:${loop.progressPct}%"></div></div>`,
+    `<p class="muted">${loop.done}/${loop.total} completados · ${loop.open} abiertos · ${loop.progressPct}%</p>`,
+    `<ul class="items">${items}</ul>`,
+    commit,
+    "</section>"
+  ].join("");
+}
+function teamPanel(team) {
+  if (team.length === 0) {
+    return [
+      '<section class="panel" id="panel-team">',
+      "<h2>Equipo</h2>",
+      '<p class="muted">Sin agentes en <code>.opencode/agent/</code>.</p>',
+      "</section>"
+    ].join("");
+  }
+  const rows = team.map((agent) => `<tr><td>${escapeHtml(agent.name)}</td><td>${escapeHtml(agent.mode)}</td><td>${escapeHtml(agentModel(agent))}</td></tr>`).join("");
+  return [
+    '<section class="panel" id="panel-team">',
+    "<h2>Equipo</h2>",
+    "<table><thead><tr><th>Agente</th><th>Modo</th><th>LLM</th></tr></thead>",
+    `<tbody>${rows}</tbody></table>`,
+    "</section>"
+  ].join("");
+}
+function routeRow(route) {
+  return `<tr><td>${route.tier}</td><td class="${route.routeKind}">${route.routeKind}</td><td>${escapeHtml(route.model)}</td><td class="hash">${escapeHtml(route.promptHash)}</td><td>${usd2(route.estimatedCostUSD)}</td><td class="good">${usd2(route.estimatedSavingsUSD)}</td></tr>`;
+}
+function routesPanel(routes) {
+  if (routes.length === 0) {
+    return [
+      '<section class="panel" id="panel-routes">',
+      "<h2>Decisiones recientes</h2>",
+      '<p class="muted">Sin decisiones de routing todavía.</p>',
+      "</section>"
+    ].join("");
+  }
+  const rows = routes.map(routeRow).join("");
+  return [
+    '<section class="panel" id="panel-routes">',
+    "<h2>Decisiones recientes</h2>",
+    "<table><thead><tr><th>Tier</th><th>Ruta</th><th>Modelo</th><th>Prompt (hash)</th><th>Coste</th><th>Ahorro</th></tr></thead>",
+    `<tbody>${rows}</tbody></table>`,
+    "</section>"
+  ].join("");
+}
+function activityRow(entry) {
+  const who = entry.agent === undefined ? "" : `<span class="who">${escapeHtml(entry.agent)}</span> `;
+  return `<li class="${entry.kind}"><span class="kind">${entry.kind}</span> ${who}${escapeHtml(entry.summary)}</li>`;
+}
+function activityPanel(activity) {
+  if (activity.length === 0) {
+    return [
+      '<section class="panel" id="panel-activity">',
+      "<h2>Actividad</h2>",
+      '<p class="muted">Sin actividad registrada.</p>',
+      "</section>"
+    ].join("");
+  }
+  const rows = activity.map(activityRow).join("");
+  return [
+    '<section class="panel" id="panel-activity">',
+    "<h2>Actividad</h2>",
+    `<ul class="timeline">${rows}</ul>`,
+    "</section>"
+  ].join("");
+}
+var STYLE = `
+:root{color-scheme:dark;--bg:#0f1115;--panel:#171a21;--fg:#e6e8eb;--muted:#8b929c;--good:#3fb950;--local:#58a6ff;--frontier:#d29922;--line:#262b34}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.5 ui-sans-serif,system-ui,Segoe UI,Roboto,sans-serif}
+header{padding:16px 24px;border-bottom:1px solid var(--line);display:flex;justify-content:space-between;align-items:baseline;gap:12px;flex-wrap:wrap}
+header h1{font-size:18px;margin:0}
+header .meta{color:var(--muted);font-size:12px}
+main{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:16px;padding:24px}
+.panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:16px}
+.panel h2{font-size:14px;margin:0 0 12px;color:var(--muted);text-transform:uppercase;letter-spacing:.04em}
+.grid{display:grid;grid-template-columns:repeat(2,1fr);gap:10px}
+.stat{display:flex;flex-direction:column;gap:2px}
+.stat .k{color:var(--muted);font-size:12px}
+.stat .v{font-size:18px;font-weight:600}
+.good{color:var(--good)}
+.local{color:var(--local)}
+.frontier{color:var(--frontier)}
+.muted{color:var(--muted)}
+table{width:100%;border-collapse:collapse;font-size:13px}
+th,td{text-align:left;padding:6px 8px;border-bottom:1px solid var(--line)}
+th{color:var(--muted);font-weight:600}
+.hash{font-family:ui-monospace,Consolas,monospace;color:var(--muted)}
+.progress{height:10px;background:#0b0d11;border-radius:6px;overflow:hidden;border:1px solid var(--line)}
+.progress .bar{height:100%;background:var(--good)}
+ul.items,ul.timeline{list-style:none;margin:8px 0 0;padding:0;max-height:320px;overflow:auto}
+ul.items li,ul.timeline li{padding:4px 0;border-bottom:1px solid var(--line)}
+ul.items li.done{color:var(--muted)}
+ul.items .box{font-family:monospace}
+.who{color:var(--local)}
+.kind{display:inline-block;min-width:66px;color:var(--muted);font-size:12px}
+code{font-family:ui-monospace,Consolas,monospace;background:#0b0d11;padding:1px 5px;border-radius:4px}
+`;
+var CLIENT_JS = `
+(function(){
+  function reloadIfChanged(prev){
+    fetch('/api/state').then(function(r){return r.json()}).then(function(s){
+      if(s.generatedAt!==prev){location.reload()}
+    }).catch(function(){});
+  }
+  var current=document.documentElement.getAttribute('data-generated')||'';
+  if('EventSource' in window){
+    try{
+      var es=new EventSource('/events');
+      es.addEventListener('state',function(){location.reload()});
+      es.onerror=function(){/* fallback below */};
+    }catch(e){/* ignore */}
+  }
+  var ms=parseInt(document.documentElement.getAttribute('data-refresh')||'2000',10);
+  setInterval(function(){reloadIfChanged(current)},isNaN(ms)?2000:Math.max(250,ms));
+})();
+`;
+function renderDashboardHtml(state, options = {}) {
+  const refreshMs = options.refreshMs ?? 2000;
+  const body = [
+    summaryPanel(state.cost),
+    loopPanel(state.loop),
+    teamPanel(state.team),
+    tierPanel(state.cost),
+    routesPanel(state.recentRoutes),
+    activityPanel(state.activity)
+  ].join("");
+  const session = state.session.id === undefined ? "" : ` · sesión ${escapeHtml(state.session.id)}`;
+  return [
+    "<!doctype html>",
+    `<html lang="es" data-generated="${escapeHtml(state.generatedAt)}" data-refresh="${refreshMs}">`,
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width,initial-scale=1">',
+    "<title>openteam dashboard</title>",
+    `<style>${STYLE}</style>`,
+    "</head>",
+    "<body>",
+    "<header>",
+    "<h1>openteam dashboard</h1>",
+    `<span class="meta">actualizado ${escapeHtml(state.generatedAt)}${session}</span>`,
+    "</header>",
+    `<main>${body}</main>`,
+    `<script>${CLIENT_JS}</script>`,
+    "</body>",
+    "</html>"
+  ].join("");
+}
+
+// src/dashboard/backlog.ts
+var ITEM_RE = /^\s*[-*+]\s+\[( |x|X)\]\s+(.*)$/;
+var ASSIGNEE_RE = /^\[@([^\]]+)\]\s*(.*)$/;
+function parseAssignee(text) {
+  const match = ASSIGNEE_RE.exec(text);
+  if (match === null) {
+    return { text: text.trim() };
+  }
+  const assignee = (match[1] ?? "").trim();
+  const rest = (match[2] ?? "").trim();
+  if (assignee.length === 0) {
+    return { text: text.trim() };
+  }
+  return { assignee, text: rest };
+}
+function parseBacklog(text) {
+  const items = [];
+  for (const line of text.split(/\r?\n/)) {
+    const match = ITEM_RE.exec(line);
+    if (match === null) {
+      continue;
+    }
+    const done = (match[1] ?? " ").toLowerCase() === "x";
+    const rawText = (match[2] ?? "").trim();
+    const { assignee, text: itemText } = parseAssignee(rawText);
+    const item = { text: itemText, done };
+    if (assignee !== undefined) {
+      item.assignee = assignee;
+    }
+    items.push(item);
+  }
+  return items;
+}
+function buildLoopSnapshot(backlogPath, items) {
+  const total = items.length;
+  const done = items.filter((item) => item.done).length;
+  const open = total - done;
+  const progressPct = total === 0 ? 100 : Math.round(done / total * 100);
+  return {
+    backlogPath,
+    total,
+    done,
+    open,
+    progressPct,
+    items: [...items]
+  };
+}
+
+// src/dashboard/state.ts
+var DEFAULT_RECENT_ROUTES = 50;
+var DEFAULT_ACTIVITY_LIMIT = 100;
+function toRouteView(record) {
+  return {
+    ts: record.ts,
+    tier: record.tier,
+    routeKind: record.routeKind,
+    model: `${record.selected.providerID}/${record.selected.modelID}`,
+    promptHash: record.promptHash,
+    estimatedCostUSD: record.estimatedCostUSD,
+    estimatedSavingsUSD: record.estimatedSavingsUSD,
+    budgetAction: record.budgetAction
+  };
+}
+function recentRoutes(records, limit) {
+  return [...records].sort((a, b) => b.ts - a.ts).slice(0, Math.max(0, limit)).map(toRouteView);
+}
+function recentActivity(entries, limit) {
+  return [...entries].sort((a, b) => b.ts - a.ts).slice(0, Math.max(0, limit));
+}
+function loopFrom(backlog) {
+  if (backlog === undefined) {
+    return;
+  }
+  const snapshot = buildLoopSnapshot(backlog.path, backlog.items);
+  if (backlog.lastCommit !== undefined) {
+    snapshot.lastCommit = backlog.lastCommit;
+  }
+  return snapshot;
+}
+function buildDashboardState(inputs) {
+  const recentRoutesLimit = inputs.recentRoutesLimit ?? DEFAULT_RECENT_ROUTES;
+  const activityLimit = inputs.activityLimit ?? DEFAULT_ACTIVITY_LIMIT;
+  const state = {
+    generatedAt: inputs.generatedAt,
+    session: {},
+    cost: summarizeCostRecords(inputs.costRecords),
+    recentRoutes: recentRoutes(inputs.costRecords, recentRoutesLimit),
+    team: [...inputs.team],
+    activity: recentActivity(inputs.activity, activityLimit)
+  };
+  if (inputs.session?.id !== undefined) {
+    state.session.id = inputs.session.id;
+  }
+  if (inputs.session?.startedAt !== undefined) {
+    state.session.startedAt = inputs.session.startedAt;
+  }
+  const loop = loopFrom(inputs.backlog);
+  if (loop !== undefined) {
+    state.loop = loop;
+  }
+  return state;
+}
+
+// src/web/server.ts
+var SSE_HEADERS = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache",
+  connection: "keep-alive"
+};
+var JSON_HEADERS = { "content-type": "application/json" };
+var HTML_HEADERS = { "content-type": "text/html; charset=utf-8" };
+function isAddressInUse(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE";
+}
+async function renderState(deps) {
+  return renderDashboardHtml(buildDashboardState(await deps.readSnapshot()), {
+    refreshMs: deps.config.refreshMs
+  });
+}
+async function stateJson(deps) {
+  return JSON.stringify(buildDashboardState(await deps.readSnapshot()));
+}
+function sseMessage(json) {
+  return `event: state
+data: ${json}
+
+`;
+}
+function createDashboardServer(deps) {
+  const serve = deps.serve ?? Bun.serve;
+  const log = deps.log ?? ((message) => console.log(message));
+  const encoder = new TextEncoder;
+  const clients = new Set;
+  const handler = async (request) => {
+    const url2 = new URL(request.url);
+    if (request.method !== "GET") {
+      return new Response("method not allowed", { status: 405 });
+    }
+    if (url2.pathname === "/" || url2.pathname === "/index.html") {
+      return new Response(await renderState(deps), { headers: HTML_HEADERS });
+    }
+    if (url2.pathname === "/api/state") {
+      return new Response(await stateJson(deps), { headers: JSON_HEADERS });
+    }
+    if (url2.pathname === "/healthz") {
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: JSON_HEADERS
+      });
+    }
+    if (url2.pathname === "/favicon.ico") {
+      return new Response(null, { status: 204 });
+    }
+    if (url2.pathname === "/events") {
+      const initial = await stateJson(deps);
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoder.encode(sseMessage(initial)));
+          clients.add(controller);
+        },
+        cancel(controller) {
+          clients.delete(controller);
+        }
+      });
+      return new Response(stream, { headers: SSE_HEADERS });
+    }
+    return new Response("not found", { status: 404 });
+  };
+  const maxAttempts = deps.config.autoPortFallback ? 20 : 1;
+  let server;
+  let lastError;
+  for (let offset = 0;offset < maxAttempts; offset += 1) {
+    const port = deps.config.port + offset;
+    if (port > 65535) {
+      break;
+    }
+    try {
+      server = serve({
+        hostname: deps.config.host,
+        port,
+        fetch: handler
+      });
+      break;
+    } catch (error) {
+      lastError = error;
+      if (!isAddressInUse(error)) {
+        throw error;
+      }
+    }
+  }
+  if (server === undefined) {
+    throw lastError ?? new Error("dashboard: no available port");
+  }
+  const boundPort = server.port ?? deps.config.port;
+  const url = `http://${deps.config.host}:${boundPort}`;
+  log(`[openteam] dashboard en ${url}`);
+  const notify = async () => {
+    if (clients.size === 0) {
+      return;
+    }
+    const message = encoder.encode(sseMessage(await stateJson(deps)));
+    for (const controller of clients) {
+      try {
+        controller.enqueue(message);
+      } catch {
+        clients.delete(controller);
+      }
+    }
+  };
+  const close = () => {
+    for (const controller of clients) {
+      try {
+        controller.close();
+      } catch {}
+    }
+    clients.clear();
+    server.stop(true);
+  };
+  return { url, port: boundPort, notify, close };
+}
+
+// src/web/snapshot.ts
+function createSnapshotReader(deps, paths, context) {
+  return async () => {
+    const [telemetryText, backlogText, agentFiles, lastCommit] = await Promise.all([
+      deps.readText(paths.telemetryPath),
+      deps.readText(paths.backlogPath),
+      deps.listAgentFiles(paths.agentDir),
+      deps.gitLastCommit?.() ?? Promise.resolve(undefined)
+    ]);
+    const costRecords = parseCostRecordsJsonl(telemetryText ?? "");
+    const team = agentFiles.map(parseAgentFile);
+    const inputs = {
+      generatedAt: deps.now(),
+      costRecords,
+      team,
+      activity: context.activity()
+    };
+    if (backlogText !== undefined) {
+      const backlog = {
+        path: paths.backlogPath,
+        items: parseBacklog(backlogText)
+      };
+      if (lastCommit !== undefined) {
+        backlog.lastCommit = lastCommit;
+      }
+      inputs.backlog = backlog;
+    }
+    if (context.session !== undefined) {
+      inputs.session = context.session;
+    }
+    if (context.recentRoutesLimit !== undefined) {
+      inputs.recentRoutesLimit = context.recentRoutesLimit;
+    }
+    return inputs;
+  };
+}
+
+// src/web/watch.ts
+function watchSources(paths, onChange, deps, debounceMs = 250) {
+  const setTimer = deps.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
+  const clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
+  const watchers = [];
+  let pending;
+  const trigger = () => {
+    if (pending !== undefined) {
+      clearTimer(pending);
+    }
+    pending = setTimer(() => {
+      pending = undefined;
+      onChange();
+    }, debounceMs);
+  };
+  for (const path of paths) {
+    try {
+      watchers.push(deps.watch(path, trigger));
+    } catch {}
+  }
+  return {
+    close() {
+      if (pending !== undefined) {
+        clearTimer(pending);
+        pending = undefined;
+      }
+      for (const watcher of watchers) {
+        watcher.close();
+      }
+    }
+  };
+}
+
+// src/web/start.ts
+function startDashboard(deps) {
+  const backlogPath = deps.backlogPath ?? DEFAULT_BACKLOG_PATH;
+  const activity = createActivityBuffer(deps.config.recentRoutes);
+  const readSnapshot = createSnapshotReader({
+    readText: deps.readText,
+    listAgentFiles: deps.listAgentFiles,
+    now: deps.now,
+    ...deps.gitLastCommit !== undefined ? { gitLastCommit: deps.gitLastCommit } : {}
+  }, {
+    telemetryPath: deps.telemetryPath,
+    backlogPath,
+    agentDir: deps.agentDir
+  }, {
+    activity: () => activity.list(),
+    recentRoutesLimit: deps.config.recentRoutes,
+    ...deps.session !== undefined ? { session: deps.session } : {}
+  });
+  const createServer = deps.serve ?? createDashboardServer;
+  const server = createServer({
+    readSnapshot,
+    config: deps.config,
+    ...deps.log !== undefined ? { log: deps.log } : {}
+  });
+  const watchFn = deps.watch ?? ((path, listener) => fsWatch(path, { persistent: false }, listener));
+  const watcher = watchSources([deps.telemetryPath, backlogPath, deps.agentDir], () => {
+    server.notify();
+  }, { watch: watchFn });
+  return {
+    url: server.url,
+    port: server.port,
+    pushActivity(entry) {
+      activity.push(entry);
+      server.notify();
+    },
+    close() {
+      watcher.close();
+      server.close();
+    }
+  };
+}
+
 // src/index.ts
 function createShellExec($) {
   return async (command, args) => {
@@ -2014,6 +2647,45 @@ function createTelemetrySink(rawOptions) {
 function isMissingFile2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+async function readTextOptional(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch (error) {
+    if (isMissingFile2(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+function createGitLastCommit(exec) {
+  return async () => {
+    const output = await exec("git", [
+      "log",
+      "-1",
+      "--pretty=format:%h%x1f%s%x1f%cI"
+    ]);
+    if (output.exitCode !== 0) {
+      return;
+    }
+    const [hash, subject, at] = output.stdout.trim().split("\x1F");
+    if (hash === undefined || subject === undefined || at === undefined) {
+      return;
+    }
+    return { hash, subject, at };
+  };
+}
+var DASHBOARD_EVENT_SUMMARIES = {
+  "session.created": "Sesión creada",
+  "session.idle": "Sesión en reposo",
+  "session.error": "Error de sesión"
+};
+function activityFromEvent(event, now) {
+  const summary = DASHBOARD_EVENT_SUMMARIES[event.type];
+  if (summary === undefined) {
+    return;
+  }
+  return { ts: now(), kind: "agent", summary };
+}
 function createCliDeps(config, registry, telemetryPath) {
   return {
     loadConfig: async (path) => {
@@ -2089,6 +2761,26 @@ var server = async (ctx, rawOptions) => {
     sink: createTelemetrySink(rawOptions)
   });
   const cliDeps = createCliDeps(config, registry, telemetryPath);
+  let dashboard;
+  if (config.dashboard.enabled) {
+    try {
+      dashboard = startDashboard({
+        config: config.dashboard,
+        telemetryPath,
+        agentDir: dirname2(ORCHESTRATOR_AGENT_PATH),
+        backlogPath: DEFAULT_BACKLOG_PATH,
+        readText: readTextOptional,
+        listAgentFiles: cliDeps.listAgentFiles,
+        now: () => new Date().toISOString(),
+        gitLastCommit: createGitLastCommit(createShellExec(ctx.$)),
+        log: (message) => console.log(`[openteam] ${message}`)
+      });
+      console.log(`[openteam] dashboard en ${dashboard.url}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[openteam] no se pudo iniciar el dashboard: ${message}`);
+    }
+  }
   return {
     ...hooks,
     tool: {
@@ -2098,6 +2790,12 @@ var server = async (ctx, rawOptions) => {
       if (event.type === "session.created" || event.type === "session.idle") {
         cache.refresh();
       }
+      if (dashboard !== undefined) {
+        const entry = activityFromEvent(event, () => Date.now());
+        if (entry !== undefined) {
+          dashboard.pushActivity(entry);
+        }
+      }
     }
   };
 };
@@ -2113,5 +2811,6 @@ export {
   isMissingFile2 as isMissingFile,
   src_default as default,
   createFileAppender,
-  createCliDeps
+  createCliDeps,
+  activityFromEvent
 };