@jmanuelcorral/openteam 0.1.20 → 0.1.22

package/dist/cli.js

@@ -2,10 +2,1659 @@
 
 // src/cli.ts
 import { execFile } from "node:child_process";
-import { access, mkdir as mkdir2, readdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { access, mkdir as mkdir2, readdir, readFile, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join2 } from "node:path";
 import { promisify } from "node:util";
 
+// src/web/start.ts
+import { watch as fsWatch } from "node:fs";
+
+// src/web/paths.ts
+var DEFAULT_BACKLOG_PATH = ".opencode/openteam-backlog.md";
+var DEFAULT_DECISIONS_PATH = ".opencode/openteam-decisions.md";
+
+// src/web/server.ts
+import {
+  createServer as createHttpServer
+} from "node:http";
+
+// src/dashboard/render.ts
+var TIERS = [
+  "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 usd(value) {
+  return `$${value.toFixed(5)}`;
+}
+function pct(value) {
+  return `${value.toFixed(2)}%`;
+}
+function ms(value) {
+  return value >= 1000 ? `${(value / 1000).toFixed(2)}s` : `${Math.round(value)}ms`;
+}
+function avgMs(stats) {
+  return stats.count === 0 ? "—" : ms(stats.totalDurationMs / stats.count);
+}
+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">${usd(cost.totalEstimatedUSD)}</span></div>`,
+    `<div class="stat"><span class="k">Baseline</span><span class="v">${usd(cost.totalBaselineUSD)}</span></div>`,
+    `<div class="stat"><span class="k">Ahorro</span><span class="v good">${usd(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 = TIERS.map((tier) => {
+    const summary = cost.byTier[tier];
+    return `<tr><td>${tier}</td><td>${summary.count}</td><td>${usd(summary.estimatedUSD)}</td><td class="good">${usd(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>${usd(route.estimatedCostUSD)}</td><td class="good">${usd(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("");
+}
+function totalsPanel(totals) {
+  const t = totals.toolcalls;
+  return [
+    '<section class="panel" id="panel-totals">',
+    "<h2>Telemetría real (todas las sesiones)</h2>",
+    '<div class="grid">',
+    `<div class="stat"><span class="k">Sesiones</span><span class="v">${totals.sessions}</span></div>`,
+    `<div class="stat"><span class="k">Mensajes</span><span class="v">${totals.messageCount}</span></div>`,
+    `<div class="stat"><span class="k">Coste real</span><span class="v">${usd(totals.realCostUSD)}</span></div>`,
+    `<div class="stat"><span class="k">Ahorro est.</span><span class="v good">${usd(totals.estimatedSavingsUSD)}</span></div>`,
+    `<div class="stat"><span class="k">Tokens in</span><span class="v">${totals.tokensIn}</span></div>`,
+    `<div class="stat"><span class="k">Tokens out</span><span class="v">${totals.tokensOut}</span></div>`,
+    `<div class="stat"><span class="k">Reasoning</span><span class="v">${totals.tokensReasoning}</span></div>`,
+    `<div class="stat"><span class="k">Cache r/w</span><span class="v">${totals.tokensCacheRead}/${totals.tokensCacheWrite}</span></div>`,
+    `<div class="stat"><span class="k">Toolcalls</span><span class="v">${t.count} <span class="good">${t.ok}✓</span> <span class="frontier">${t.failed}✗</span></span></div>`,
+    `<div class="stat"><span class="k">Dur. media tool</span><span class="v">${avgMs(t)}</span></div>`,
+    "</div>",
+    "</section>"
+  ].join("");
+}
+function sessionRow(session) {
+  const models = session.models.map(escapeHtml).join("<br>") || "—";
+  return [
+    "<tr>",
+    `<td class="hash">${escapeHtml(session.sessionID)}</td>`,
+    `<td>${models}</td>`,
+    `<td><span class="local">${session.localCount}</span>/<span class="frontier">${session.frontierCount}</span></td>`,
+    `<td>${usd(session.realCostUSD)}</td>`,
+    `<td>${session.tokensIn}/${session.tokensOut}</td>`,
+    `<td>${session.toolcalls.count} (${avgMs(session.toolcalls)})</td>`,
+    "</tr>"
+  ].join("");
+}
+function sessionsPanel(sessions) {
+  if (sessions.length === 0) {
+    return [
+      '<section class="panel" id="panel-sessions">',
+      "<h2>Sesiones</h2>",
+      '<p class="muted">Sin sesiones registradas todavía.</p>',
+      "</section>"
+    ].join("");
+  }
+  const rows = sessions.map(sessionRow).join("");
+  return [
+    '<section class="panel" id="panel-sessions">',
+    "<h2>Sesiones</h2>",
+    "<table><thead><tr><th>Sesión</th><th>Modelos</th><th>L/F</th><th>Coste</th><th>Tok in/out</th><th>Tools</th></tr></thead>",
+    `<tbody>${rows}</tbody></table>`,
+    "</section>"
+  ].join("");
+}
+function decisionRow(decision) {
+  const who = decision.agent === undefined ? "" : `<span class="who">${escapeHtml(decision.agent)}</span> `;
+  const tags = decision.tags === undefined || decision.tags.length === 0 ? "" : ` ${decision.tags.map((tag) => `<span class="tag">#${escapeHtml(tag)}</span>`).join(" ")}`;
+  return `<li class="decision"><span class="kind">decision</span> ${who}${escapeHtml(decision.summary)}${tags}</li>`;
+}
+function decisionsPanel(decisions) {
+  if (decisions.length === 0) {
+    return [
+      '<section class="panel" id="panel-decisions">',
+      "<h2>Decisiones</h2>",
+      '<p class="muted">Sin decisiones registradas (el scribe escribe en <code>openteam-decisions.md</code>).</p>',
+      "</section>"
+    ].join("");
+  }
+  const rows = decisions.map(decisionRow).join("");
+  return [
+    '<section class="panel" id="panel-decisions">',
+    "<h2>Decisiones</h2>",
+    `<ul class="timeline">${rows}</ul>`,
+    "</section>"
+  ].join("");
+}
+function meetingRow(meeting) {
+  const roles = meeting.roles.map(escapeHtml).join(", ");
+  const purpose = meeting.purpose === undefined ? "" : `: ${escapeHtml(meeting.purpose)}`;
+  return `<li class="agent"><span class="kind">reunión</span> <span class="who">${roles}</span>${purpose}</li>`;
+}
+function meetingsPanel(meetings) {
+  if (meetings.length === 0) {
+    return [
+      '<section class="panel" id="panel-meetings">',
+      "<h2>Reuniones</h2>",
+      '<p class="muted">Sin reuniones multi-agente todavía.</p>',
+      "</section>"
+    ].join("");
+  }
+  const rows = meetings.map(meetingRow).join("");
+  return [
+    '<section class="panel" id="panel-meetings">',
+    "<h2>Reuniones</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)}
+.tag{color:var(--frontier);font-size:12px}
+.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),
+    totalsPanel(state.totals),
+    sessionsPanel(state.sessions),
+    loopPanel(state.loop),
+    teamPanel(state.team),
+    tierPanel(state.cost),
+    routesPanel(state.recentRoutes),
+    decisionsPanel(state.decisions),
+    meetingsPanel(state.meetings),
+    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/commands/report.ts
+var TIERS2 = [
+  "trivial",
+  "simple",
+  "moderate",
+  "hard"
+];
+function emptyTierSummary() {
+  return {
+    trivial: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
+    simple: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
+    moderate: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
+    hard: { count: 0, estimatedUSD: 0, savingsUSD: 0 }
+  };
+}
+function summarizeCostRecords(records) {
+  const report = {
+    count: 0,
+    localCount: 0,
+    frontierCount: 0,
+    totalEstimatedUSD: 0,
+    totalBaselineUSD: 0,
+    totalSavingsUSD: 0,
+    savingsPct: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    byTier: emptyTierSummary()
+  };
+  for (const record of records) {
+    report.count += 1;
+    if (record.routeKind === "local") {
+      report.localCount += 1;
+    } else {
+      report.frontierCount += 1;
+    }
+    report.totalEstimatedUSD += record.estimatedCostUSD;
+    report.totalBaselineUSD += record.baselineCostUSD;
+    report.totalSavingsUSD += record.estimatedSavingsUSD;
+    report.tokensIn += record.tokensIn ?? 0;
+    report.tokensOut += record.tokensOut ?? 0;
+    const tier = report.byTier[record.tier];
+    tier.count += 1;
+    tier.estimatedUSD += record.estimatedCostUSD;
+    tier.savingsUSD += record.estimatedSavingsUSD;
+  }
+  report.savingsPct = report.totalBaselineUSD > 0 ? report.totalSavingsUSD / report.totalBaselineUSD * 100 : 0;
+  return report;
+}
+function usd2(value) {
+  return `$${value.toFixed(5)}`;
+}
+function renderReport(report) {
+  if (report.count === 0) {
+    return "openteam report: sin registros de telemetría todavía.";
+  }
+  const lines = [
+    "openteam report:",
+    `  decisiones:   ${report.count} (local ${report.localCount} · frontier ${report.frontierCount})`,
+    `  coste real:   ${usd2(report.totalEstimatedUSD)}`,
+    `  baseline:     ${usd2(report.totalBaselineUSD)}`,
+    `  ahorro:       ${usd2(report.totalSavingsUSD)} (${report.savingsPct.toFixed(2)}%)`,
+    `  tokens:       in ${report.tokensIn} · out ${report.tokensOut}`,
+    "  por tier:"
+  ];
+  for (const tier of TIERS2) {
+    const summary = report.byTier[tier];
+    lines.push(`    ${tier.padEnd(9)} ${summary.count} · coste ${usd2(summary.estimatedUSD)} · ahorro ${usd2(summary.savingsUSD)}`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/telemetry/aggregate.ts
+function emptyToolcallStats() {
+  return { count: 0, ok: 0, failed: 0, totalDurationMs: 0, byTool: {} };
+}
+function emptySession(sessionID, ts) {
+  return {
+    sessionID,
+    firstTs: ts,
+    lastTs: ts,
+    routeCount: 0,
+    localCount: 0,
+    frontierCount: 0,
+    estimatedCostUSD: 0,
+    estimatedSavingsUSD: 0,
+    realCostUSD: 0,
+    messageCount: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    tokensReasoning: 0,
+    tokensCacheRead: 0,
+    tokensCacheWrite: 0,
+    toolcalls: emptyToolcallStats(),
+    models: [],
+    agents: []
+  };
+}
+function pushUnique(list, value) {
+  if (value !== undefined && !list.includes(value)) {
+    list.push(value);
+  }
+}
+function applyRoute(session, event) {
+  session.routeCount += 1;
+  if (event.routeKind === "local") {
+    session.localCount += 1;
+  } else {
+    session.frontierCount += 1;
+  }
+  session.estimatedCostUSD += event.estimatedCostUSD;
+  session.estimatedSavingsUSD += event.estimatedSavingsUSD;
+  pushUnique(session.models, `${event.selected.providerID}/${event.selected.modelID}`);
+  pushUnique(session.agents, event.agent);
+}
+function applyMessage(session, event) {
+  session.messageCount += 1;
+  session.realCostUSD += event.costUSD;
+  session.tokensIn += event.tokensIn;
+  session.tokensOut += event.tokensOut;
+  session.tokensReasoning += event.tokensReasoning;
+  session.tokensCacheRead += event.tokensCacheRead;
+  session.tokensCacheWrite += event.tokensCacheWrite;
+  pushUnique(session.models, `${event.providerID}/${event.modelID}`);
+  pushUnique(session.agents, event.agent);
+}
+function applyToolUsage(stats, event) {
+  stats.count += 1;
+  stats.totalDurationMs += event.durationMs;
+  if (event.ok) {
+    stats.ok += 1;
+  } else {
+    stats.failed += 1;
+  }
+}
+function applyToolcall(session, event) {
+  applyToolUsage(session.toolcalls, event);
+  const byTool = session.toolcalls.byTool[event.tool] ?? {
+    count: 0,
+    ok: 0,
+    failed: 0,
+    totalDurationMs: 0
+  };
+  applyToolUsage(byTool, event);
+  session.toolcalls.byTool[event.tool] = byTool;
+  pushUnique(session.agents, event.agent);
+}
+function mergeTool(target, source) {
+  target.count += source.count;
+  target.ok += source.ok;
+  target.failed += source.failed;
+  target.totalDurationMs += source.totalDurationMs;
+}
+function accumulateTotals(totals, session) {
+  totals.sessions += 1;
+  totals.routeCount += session.routeCount;
+  totals.localCount += session.localCount;
+  totals.frontierCount += session.frontierCount;
+  totals.estimatedCostUSD += session.estimatedCostUSD;
+  totals.estimatedSavingsUSD += session.estimatedSavingsUSD;
+  totals.realCostUSD += session.realCostUSD;
+  totals.messageCount += session.messageCount;
+  totals.tokensIn += session.tokensIn;
+  totals.tokensOut += session.tokensOut;
+  totals.tokensReasoning += session.tokensReasoning;
+  totals.tokensCacheRead += session.tokensCacheRead;
+  totals.tokensCacheWrite += session.tokensCacheWrite;
+  mergeTool(totals.toolcalls, session.toolcalls);
+  for (const [tool, usage] of Object.entries(session.toolcalls.byTool)) {
+    const target = totals.toolcalls.byTool[tool] ?? {
+      count: 0,
+      ok: 0,
+      failed: 0,
+      totalDurationMs: 0
+    };
+    mergeTool(target, usage);
+    totals.toolcalls.byTool[tool] = target;
+  }
+}
+function toDecision(event) {
+  const view = {
+    ts: event.ts,
+    sessionID: event.sessionID,
+    summary: event.summary
+  };
+  if (event.agent !== undefined) {
+    view.agent = event.agent;
+  }
+  if (event.tags !== undefined) {
+    view.tags = [...event.tags];
+  }
+  return view;
+}
+function toMeeting(event) {
+  const view = {
+    ts: event.ts,
+    sessionID: event.sessionID,
+    batchID: event.batchID,
+    roles: [...event.roles]
+  };
+  if (event.purpose !== undefined) {
+    view.purpose = event.purpose;
+  }
+  if (event.decisionIDs !== undefined) {
+    view.decisionIDs = [...event.decisionIDs];
+  }
+  return view;
+}
+function toActivity(event) {
+  const view = {
+    ts: event.ts,
+    sessionID: event.sessionID,
+    kind: event.kind,
+    summary: event.summary
+  };
+  if (event.agent !== undefined) {
+    view.agent = event.agent;
+  }
+  return view;
+}
+function byTsDesc(list) {
+  return [...list].sort((a, b) => b.ts - a.ts);
+}
+function aggregateEvents(events) {
+  const sessions = new Map;
+  const decisions = [];
+  const meetings = [];
+  const activity = [];
+  const sessionFor = (sessionID, ts) => {
+    const existing = sessions.get(sessionID);
+    if (existing === undefined) {
+      const created = emptySession(sessionID, ts);
+      sessions.set(sessionID, created);
+      return created;
+    }
+    existing.firstTs = Math.min(existing.firstTs, ts);
+    existing.lastTs = Math.max(existing.lastTs, ts);
+    return existing;
+  };
+  for (const event of events) {
+    switch (event.type) {
+      case "route":
+        applyRoute(sessionFor(event.sessionID, event.ts), event);
+        break;
+      case "message":
+        applyMessage(sessionFor(event.sessionID, event.ts), event);
+        break;
+      case "toolcall":
+        applyToolcall(sessionFor(event.sessionID, event.ts), event);
+        break;
+      case "decision":
+        decisions.push(toDecision(event));
+        break;
+      case "meeting":
+        meetings.push(toMeeting(event));
+        break;
+      case "activity":
+        activity.push(toActivity(event));
+        break;
+    }
+  }
+  const totals = {
+    sessions: 0,
+    routeCount: 0,
+    localCount: 0,
+    frontierCount: 0,
+    estimatedCostUSD: 0,
+    estimatedSavingsUSD: 0,
+    realCostUSD: 0,
+    messageCount: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    tokensReasoning: 0,
+    tokensCacheRead: 0,
+    tokensCacheWrite: 0,
+    toolcalls: emptyToolcallStats()
+  };
+  const summaries = [...sessions.values()].sort((a, b) => b.lastTs - a.lastTs);
+  for (const summary of summaries) {
+    summary.models.sort();
+    summary.agents.sort();
+    accumulateTotals(totals, summary);
+  }
+  return {
+    sessions: summaries,
+    totals,
+    decisions: byTsDesc(decisions),
+    meetings: byTsDesc(meetings),
+    activity: byTsDesc(activity)
+  };
+}
+
+// src/telemetry/events.ts
+import { z as z3 } from "zod";
+
+// src/capabilities/types.ts
+import { z } from "zod";
+var CapabilityTierSchema = z.union([
+  z.literal(0),
+  z.literal(1),
+  z.literal(2),
+  z.literal(3),
+  z.literal(4),
+  z.literal(5)
+]);
+var ComplexityTierSchema = z.enum([
+  "trivial",
+  "simple",
+  "moderate",
+  "hard"
+]);
+var ModelCapabilityProfileSchema = z.object({
+  ref: z.object({
+    providerID: z.string().min(1),
+    modelID: z.string().min(1)
+  }),
+  kind: z.enum(["local", "frontier", "router"]),
+  contextWindow: z.number().int().positive(),
+  maxOutputTokens: z.number().int().positive(),
+  supportsToolCalling: z.boolean(),
+  supportsVision: z.boolean(),
+  reasoningTier: CapabilityTierSchema,
+  codeQualityTier: CapabilityTierSchema,
+  costPer1M: z.object({
+    inputUSD: z.number().min(0),
+    outputUSD: z.number().min(0)
+  }),
+  availability: z.enum(["available", "degraded", "unavailable"])
+});
+
+// src/config/schema.ts
+import { z as z2 } from "zod";
+var ModelRefSchema = z2.object({
+  providerID: z2.string().min(1),
+  modelID: z2.string().min(1)
+});
+var RouterModeSchema = z2.enum(["economy", "balanced", "quality"]);
+var PrivacyModeSchema = z2.enum([
+  "forceLocalOnSensitive",
+  "consentBeforeFrontier",
+  "off"
+]);
+var BaselineModeSchema = z2.enum(["auto", "pinned"]);
+var DashboardHostSchema = z2.enum(["127.0.0.1", "localhost"]);
+var DashboardConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  host: DashboardHostSchema.default("127.0.0.1"),
+  port: z2.number().int().min(1024).max(65535).default(4599),
+  autoPortFallback: z2.boolean().default(true),
+  refreshMs: z2.number().int().min(250).default(2000),
+  recentRoutes: z2.number().int().positive().default(50),
+  openBrowser: z2.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"
+};
+var defaultFrontierModel = {
+  providerID: "anthropic",
+  modelID: "claude-sonnet-4-5"
+};
+var LocalRuntimeSchema = z2.object({
+  id: z2.enum(["ollama", "lmstudio", "foundry-local"]),
+  enabled: z2.boolean().default(true),
+  baseURL: z2.string().url().optional(),
+  discovery: z2.enum(["cli", "sdk", "manual"]).optional(),
+  defaultModel: ModelRefSchema
+});
+var OpenTeamConfigSchema = z2.object({
+  baseline: z2.object({
+    mode: BaselineModeSchema.default("auto"),
+    pinnedModel: ModelRefSchema.nullable().default(null),
+    hardDefault: ModelRefSchema.default(defaultFrontierModel)
+  }).default({
+    mode: "auto",
+    pinnedModel: null,
+    hardDefault: defaultFrontierModel
+  }),
+  router: z2.object({
+    mode: RouterModeSchema.default("balanced"),
+    localDefault: ModelRefSchema.default(defaultLocalModel),
+    trivialPromptMaxChars: z2.number().int().positive().default(280),
+    frontierPromptMinChars: z2.number().int().positive().default(2000)
+  }).default({
+    mode: "balanced",
+    localDefault: defaultLocalModel,
+    trivialPromptMaxChars: 280,
+    frontierPromptMinChars: 2000
+  }),
+  local: z2.object({
+    runtimes: z2.array(LocalRuntimeSchema).min(1).default([
+      {
+        id: "ollama",
+        enabled: true,
+        baseURL: "http://localhost:11434/v1",
+        defaultModel: { providerID: "ollama", modelID: "qwen3:8b" }
+      }
+    ])
+  }).default({
+    runtimes: [
+      {
+        id: "ollama",
+        enabled: true,
+        baseURL: "http://localhost:11434/v1",
+        defaultModel: defaultLocalModel
+      }
+    ]
+  }),
+  budgets: z2.object({
+    sessionUSD: z2.number().positive().optional(),
+    monthlyUSD: z2.number().positive().optional(),
+    frontierTokensPerSession: z2.number().int().positive().optional(),
+    hardStopOnBudgetExhaustion: z2.boolean().default(false)
+  }).default({ hardStopOnBudgetExhaustion: false }),
+  privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
+  dashboard: DashboardConfigSchema
+});
+
+// src/telemetry/events.ts
+var EVENT_SCHEMA_VERSION = 1;
+var EventBaseSchema = z3.object({
+  v: z3.literal(EVENT_SCHEMA_VERSION),
+  ts: z3.number().finite(),
+  sessionID: z3.string().min(1)
+});
+var RouteEventSchema = EventBaseSchema.extend({
+  type: z3.literal("route"),
+  promptHash: z3.string().min(1),
+  promptChars: z3.number().int().min(0),
+  tier: ComplexityTierSchema,
+  routeKind: z3.enum(["local", "frontier"]),
+  selected: ModelRefSchema,
+  rationale: z3.string(),
+  estimatedCostUSD: z3.number().finite().min(0),
+  baselineCostUSD: z3.number().finite().min(0),
+  estimatedSavingsUSD: z3.number().finite(),
+  budgetAction: z3.string().min(1),
+  tokensIn: z3.number().int().min(0).optional(),
+  tokensOut: z3.number().int().min(0).optional(),
+  decisionID: z3.string().min(1).optional(),
+  agent: z3.string().min(1).optional(),
+  success: z3.boolean().optional(),
+  batchID: z3.string().min(1).optional(),
+  failureReason: z3.string().min(1).optional(),
+  failureStage: z3.string().min(1).optional()
+});
+var MessageEventSchema = EventBaseSchema.extend({
+  type: z3.literal("message"),
+  providerID: z3.string().min(1),
+  modelID: z3.string().min(1),
+  agent: z3.string().min(1).optional(),
+  mode: z3.string().min(1).optional(),
+  messageID: z3.string().min(1).optional(),
+  costUSD: z3.number().finite().min(0),
+  tokensIn: z3.number().int().min(0),
+  tokensOut: z3.number().int().min(0),
+  tokensReasoning: z3.number().int().min(0),
+  tokensCacheRead: z3.number().int().min(0),
+  tokensCacheWrite: z3.number().int().min(0),
+  durationMs: z3.number().int().min(0)
+});
+var ToolcallEventSchema = EventBaseSchema.extend({
+  type: z3.literal("toolcall"),
+  tool: z3.string().min(1),
+  callID: z3.string().min(1),
+  agent: z3.string().min(1).optional(),
+  durationMs: z3.number().int().min(0),
+  ok: z3.boolean(),
+  title: z3.string().optional()
+});
+var MeetingEventSchema = EventBaseSchema.extend({
+  type: z3.literal("meeting"),
+  batchID: z3.string().min(1),
+  purpose: z3.string().optional(),
+  roles: z3.array(z3.string().min(1)),
+  decisionIDs: z3.array(z3.string().min(1)).optional()
+});
+var DecisionEventSchema = EventBaseSchema.extend({
+  type: z3.literal("decision"),
+  agent: z3.string().min(1).optional(),
+  summary: z3.string().min(1),
+  tags: z3.array(z3.string().min(1)).optional()
+});
+var ActivityEventSchema = EventBaseSchema.extend({
+  type: z3.literal("activity"),
+  kind: z3.enum(["route", "agent", "decision", "commit"]),
+  agent: z3.string().min(1).optional(),
+  summary: z3.string().min(1)
+});
+var OpenTeamEventSchema = z3.discriminatedUnion("type", [
+  RouteEventSchema,
+  MessageEventSchema,
+  ToolcallEventSchema,
+  MeetingEventSchema,
+  DecisionEventSchema,
+  ActivityEventSchema
+]);
+
+// src/telemetry/types.ts
+import { z as z4 } from "zod";
+var CostRecordSchema = z4.object({
+  ts: z4.number().finite(),
+  sessionID: z4.string().min(1).optional(),
+  promptHash: z4.string().min(1),
+  promptChars: z4.number().int().min(0),
+  tier: ComplexityTierSchema,
+  routeKind: z4.enum(["local", "frontier"]),
+  selected: ModelRefSchema,
+  rationale: z4.string(),
+  estimatedCostUSD: z4.number().finite().min(0),
+  baselineCostUSD: z4.number().finite().min(0),
+  estimatedSavingsUSD: z4.number().finite(),
+  budgetAction: z4.string().min(1),
+  tokensIn: z4.number().int().min(0).optional(),
+  tokensOut: z4.number().int().min(0).optional()
+});
+
+// src/telemetry/read.ts
+var DEFAULT_TELEMETRY_PATH = ".opencode/openteam-telemetry.jsonl";
+function parseCostRecordsJsonl(text) {
+  const records = [];
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    let candidate;
+    try {
+      candidate = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const parsed = CostRecordSchema.safeParse(candidate);
+    if (parsed.success) {
+      records.push(parsed.data);
+    }
+  }
+  return records;
+}
+
+// src/telemetry/eventLog.ts
+var DEFAULT_SESSIONS_DIR = ".opencode/openteam/sessions";
+var LEGACY_SESSION_ID = "legacy";
+function defaultJoin(dir, file) {
+  return dir.endsWith("/") ? `${dir}${file}` : `${dir}/${file}`;
+}
+function parseEventsJsonl(text) {
+  const events = [];
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    let candidate;
+    try {
+      candidate = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const parsed = OpenTeamEventSchema.safeParse(candidate);
+    if (parsed.success) {
+      events.push(parsed.data);
+    }
+  }
+  return events;
+}
+function costRecordToRouteEvent(record) {
+  const event = {
+    v: EVENT_SCHEMA_VERSION,
+    type: "route",
+    ts: record.ts,
+    sessionID: record.sessionID ?? LEGACY_SESSION_ID,
+    promptHash: record.promptHash,
+    promptChars: record.promptChars,
+    tier: record.tier,
+    routeKind: record.routeKind,
+    selected: record.selected,
+    rationale: record.rationale,
+    estimatedCostUSD: record.estimatedCostUSD,
+    baselineCostUSD: record.baselineCostUSD,
+    estimatedSavingsUSD: record.estimatedSavingsUSD,
+    budgetAction: record.budgetAction
+  };
+  if (record.tokensIn !== undefined) {
+    event.tokensIn = record.tokensIn;
+  }
+  if (record.tokensOut !== undefined) {
+    event.tokensOut = record.tokensOut;
+  }
+  return event;
+}
+function routeEventToCostRecord(event) {
+  const record = {
+    ts: event.ts,
+    sessionID: event.sessionID,
+    promptHash: event.promptHash,
+    promptChars: event.promptChars,
+    tier: event.tier,
+    routeKind: event.routeKind,
+    selected: event.selected,
+    rationale: event.rationale,
+    estimatedCostUSD: event.estimatedCostUSD,
+    baselineCostUSD: event.baselineCostUSD,
+    estimatedSavingsUSD: event.estimatedSavingsUSD,
+    budgetAction: event.budgetAction
+  };
+  if (event.tokensIn !== undefined) {
+    record.tokensIn = event.tokensIn;
+  }
+  if (event.tokensOut !== undefined) {
+    record.tokensOut = event.tokensOut;
+  }
+  return record;
+}
+async function readRouteCostRecords(dir, deps) {
+  const events = await readSessionEvents(dir, deps);
+  const records = [];
+  for (const event of events) {
+    if (event.type === "route") {
+      records.push(routeEventToCostRecord(event));
+    }
+  }
+  return records;
+}
+async function readSessionEvents(dir, deps) {
+  const join = deps.join ?? defaultJoin;
+  const files = (await deps.listFiles(dir)).filter((file) => file.endsWith(".jsonl"));
+  const perFile = await Promise.all(files.map(async (file) => {
+    const text = await deps.readText(join(dir, file));
+    return text === undefined ? [] : parseEventsJsonl(text);
+  }));
+  const events = perFile.flat();
+  if (deps.legacyTelemetryPath !== undefined) {
+    const legacyText = await deps.readText(deps.legacyTelemetryPath);
+    if (legacyText !== undefined) {
+      for (const record of parseCostRecordsJsonl(legacyText)) {
+        events.push(costRecordToRouteEvent(record));
+      }
+    }
+  }
+  return events.sort((a, b) => a.ts - b.ts);
+}
+
+// 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;
+var DEFAULT_DECISIONS_LIMIT = 100;
+var DEFAULT_MEETINGS_LIMIT = 50;
+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 isRoute(event) {
+  return event.type === "route";
+}
+function recentRoutes(records, limit) {
+  return [...records].sort((a, b) => b.ts - a.ts).slice(0, Math.max(0, limit)).map(toRouteView);
+}
+function decisionToActivity(decision) {
+  const entry = {
+    ts: decision.ts,
+    kind: "decision",
+    summary: decision.summary
+  };
+  if (decision.agent !== undefined) {
+    entry.agent = decision.agent;
+  }
+  return entry;
+}
+function meetingToActivity(meeting) {
+  const roles = meeting.roles.join(", ");
+  const purpose = meeting.purpose === undefined ? "" : `: ${meeting.purpose}`;
+  return {
+    ts: meeting.ts,
+    kind: "agent",
+    summary: `Reunión (${roles})${purpose}`
+  };
+}
+function activityFeed(aggregate, limit) {
+  const entries = [
+    ...aggregate.activity.map((view) => {
+      const entry = {
+        ts: view.ts,
+        kind: view.kind,
+        summary: view.summary
+      };
+      if (view.agent !== undefined) {
+        entry.agent = view.agent;
+      }
+      return entry;
+    }),
+    ...aggregate.decisions.map(decisionToActivity),
+    ...aggregate.meetings.map(meetingToActivity)
+  ];
+  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 decisionsLimit = inputs.decisionsLimit ?? DEFAULT_DECISIONS_LIMIT;
+  const meetingsLimit = inputs.meetingsLimit ?? DEFAULT_MEETINGS_LIMIT;
+  const aggregate = aggregateEvents(inputs.events);
+  const costRecords = inputs.events.filter(isRoute).map(routeEventToCostRecord);
+  const state = {
+    generatedAt: inputs.generatedAt,
+    session: {},
+    cost: summarizeCostRecords(costRecords),
+    totals: aggregate.totals,
+    sessions: aggregate.sessions,
+    recentRoutes: recentRoutes(costRecords, recentRoutesLimit),
+    decisions: aggregate.decisions.slice(0, Math.max(0, decisionsLimit)),
+    meetings: aggregate.meetings.slice(0, Math.max(0, meetingsLimit)),
+    team: [...inputs.team],
+    activity: activityFeed(aggregate, 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 tryListen(server, host, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.removeListener("listening", onListening);
+      if (isAddressInUse(error)) {
+        resolve(false);
+      } else {
+        reject(error);
+      }
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      resolve(true);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+}
+async function createDashboardServer(deps) {
+  const create = deps.createServer ?? createHttpServer;
+  const log = deps.log ?? ((message) => console.log(message));
+  const clients = new Set;
+  const handle = async (request, response) => {
+    if (request.method !== "GET") {
+      response.writeHead(405).end("method not allowed");
+      return;
+    }
+    const url2 = new URL(request.url ?? "/", "http://localhost");
+    const path = url2.pathname;
+    if (path === "/" || path === "/index.html") {
+      response.writeHead(200, HTML_HEADERS).end(await renderState(deps));
+      return;
+    }
+    if (path === "/api/state") {
+      response.writeHead(200, JSON_HEADERS).end(await stateJson(deps));
+      return;
+    }
+    if (path === "/healthz") {
+      response.writeHead(200, JSON_HEADERS).end(JSON.stringify({ ok: true }));
+      return;
+    }
+    if (path === "/favicon.ico") {
+      response.writeHead(204).end();
+      return;
+    }
+    if (path === "/events") {
+      response.writeHead(200, SSE_HEADERS);
+      response.write(sseMessage(await stateJson(deps)));
+      clients.add(response);
+      request.on("close", () => {
+        clients.delete(response);
+      });
+      return;
+    }
+    response.writeHead(404).end("not found");
+  };
+  const server = create((request, response) => {
+    handle(request, response);
+  });
+  const maxAttempts = deps.config.autoPortFallback ? 20 : 1;
+  let bound = false;
+  let boundPort = deps.config.port;
+  for (let offset = 0;offset < maxAttempts; offset += 1) {
+    const port = deps.config.port + offset;
+    if (port > 65535) {
+      break;
+    }
+    if (await tryListen(server, deps.config.host, port)) {
+      boundPort = port;
+      bound = true;
+      break;
+    }
+  }
+  if (!bound) {
+    throw new Error("dashboard: no available port");
+  }
+  const url = `http://${deps.config.host}:${boundPort}`;
+  log(`[openteam] dashboard en ${url}`);
+  const notify = async () => {
+    if (clients.size === 0) {
+      return;
+    }
+    const message = sseMessage(await stateJson(deps));
+    for (const response of clients) {
+      response.write(message);
+    }
+  };
+  const close = () => {
+    for (const response of clients) {
+      response.end();
+    }
+    clients.clear();
+    server.close();
+    server.closeAllConnections?.();
+  };
+  return { url, port: boundPort, notify, close };
+}
+
+// src/commands/agents.ts
+var PROVIDER_LABELS = {
+  "github-copilot": "GitHub Copilot",
+  anthropic: "Anthropic",
+  openai: "OpenAI",
+  google: "Google",
+  openrouter: "OpenRouter",
+  ollama: "Ollama",
+  lmstudio: "LM Studio",
+  "foundry-local": "Foundry Local"
+};
+function providerLabel(providerID) {
+  return PROVIDER_LABELS[providerID] ?? providerID;
+}
+function unquote(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2 && (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseModelValue(value) {
+  const raw = unquote(value);
+  const slash = raw.indexOf("/");
+  if (slash <= 0 || slash === raw.length - 1) {
+    return;
+  }
+  return { providerID: raw.slice(0, slash), modelID: raw.slice(slash + 1) };
+}
+function parseAgentFile(file) {
+  const info = { name: file.name, mode: "subagent" };
+  const lines = file.contents.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    return info;
+  }
+  for (let i = 1;i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "---") {
+      break;
+    }
+    const colon = line.indexOf(":");
+    if (colon <= 0) {
+      continue;
+    }
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).trim();
+    if (key === "mode") {
+      info.mode = unquote(value) || "subagent";
+    } else if (key === "description") {
+      info.description = unquote(value);
+    } else if (key === "model") {
+      const model = parseModelValue(value);
+      if (model !== undefined) {
+        info.model = model;
+      }
+    }
+  }
+  return info;
+}
+function localProviderIDs(config) {
+  const ids = new Set;
+  for (const runtime of config.local.runtimes) {
+    ids.add(runtime.id);
+    ids.add(runtime.defaultModel.providerID);
+  }
+  ids.add(config.router.localDefault.providerID);
+  return ids;
+}
+function subscriptionLabel(model, localProviders) {
+  const isLocal = localProviders.has(model.providerID);
+  if (isLocal) {
+    return {
+      kind: "local",
+      subscription: `local · ${providerLabel(model.providerID)} (sin coste de tokens)`
+    };
+  }
+  return {
+    kind: "frontier",
+    subscription: `frontier · ${providerLabel(model.providerID)} (consume tu suscripción)`
+  };
+}
+function classifyAgent(info, context) {
+  if (info.model !== undefined) {
+    const { kind, subscription: subscription2 } = subscriptionLabel(info.model, context.localProviders);
+    return {
+      name: info.name,
+      mode: info.mode,
+      kind,
+      model: info.model,
+      subscription: subscription2
+    };
+  }
+  if (context.defaultModel === undefined) {
+    return {
+      name: info.name,
+      mode: info.mode,
+      kind: "inherited",
+      subscription: "hereda el default de opencode.json (sin definir) · openteam enruta local-first por mensaje"
+    };
+  }
+  const { subscription } = subscriptionLabel(context.defaultModel, context.localProviders);
+  return {
+    name: info.name,
+    mode: info.mode,
+    kind: "inherited",
+    model: context.defaultModel,
+    subscription: `hereda default → ${subscription} · openteam enruta local-first por mensaje`
+  };
+}
+function modeRank(mode) {
+  if (mode === "primary") {
+    return 0;
+  }
+  if (mode === "all") {
+    return 1;
+  }
+  return 2;
+}
+function classifyAgents(files, context) {
+  return files.map((file) => classifyAgent(parseAgentFile(file), context)).sort((a, b) => {
+    const rank = modeRank(a.mode) - modeRank(b.mode);
+    return rank !== 0 ? rank : a.name.localeCompare(b.name);
+  });
+}
+function modelText(classification) {
+  return classification.model === undefined ? "" : ` (${classification.model.providerID}/${classification.model.modelID})`;
+}
+function renderAgentList(classifications, context) {
+  const lines = ["openteam agents — LLM por agente:", ""];
+  if (classifications.length === 0) {
+    lines.push("  (sin agentes en .opencode/agent/) — ejecuta 'openteam setup' o pide al orquestador que cree el equipo.");
+    return lines.join(`
+`);
+  }
+  const nameWidth = Math.max(...classifications.map((c) => c.name.length), "agente".length);
+  const modeWidth = Math.max(...classifications.map((c) => c.mode.length), "subagent".length);
+  for (const c of classifications) {
+    const bullet = c.mode === "primary" ? "●" : "○";
+    lines.push(`  ${bullet} ${c.name.padEnd(nameWidth)}  [${c.mode.padEnd(modeWidth)}]  ${c.subscription}${modelText(c)}`);
+  }
+  lines.push("");
+  if (context.defaultModel !== undefined) {
+    const { kind } = subscriptionLabel(context.defaultModel, context.localProviders);
+    lines.push(`Default de opencode.json: ${context.defaultModel.providerID}/${context.defaultModel.modelID} (${kind} · ${providerLabel(context.defaultModel.providerID)})`);
+  } else {
+    lines.push("Default de opencode.json: (sin definir)");
+  }
+  lines.push("Leyenda: ● primary · ○ subagent · local = sin coste de tokens · frontier = consume tu suscripción.");
+  return lines.join(`
+`);
+}
+
+// src/telemetry/decisions.ts
+var DECISIONS_SESSION_ID = "decisions";
+var BULLET_RE = /^\s*[-*]\s+(.+?)\s*$/;
+var DATE_RE = /^(\d{4}-\d{2}-\d{2})\b\s*/;
+var AGENT_RE = /^\[([^\]]+)\]\s*/;
+var TAG_RE = /#([A-Za-z0-9][\w-]*)/g;
+function parseDate(value) {
+  const parsed = Date.parse(`${value}T00:00:00Z`);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+function parseDecisionsMarkdown(text, options = {}) {
+  const sessionID = options.sessionID ?? DECISIONS_SESSION_ID;
+  const baseTs = options.baseTs ?? 0;
+  const events = [];
+  let index = 0;
+  for (const line of text.split(`
+`)) {
+    const bullet = BULLET_RE.exec(line);
+    if (bullet === null) {
+      continue;
+    }
+    let content = bullet[1] ?? "";
+    let ts = baseTs + index;
+    const dateMatch = DATE_RE.exec(content);
+    if (dateMatch?.[1] !== undefined) {
+      const parsed = parseDate(dateMatch[1]);
+      if (parsed !== undefined) {
+        ts = parsed;
+        content = content.slice(dateMatch[0].length);
+      }
+    }
+    let agent;
+    const agentMatch = AGENT_RE.exec(content);
+    if (agentMatch?.[1] !== undefined) {
+      agent = agentMatch[1].trim();
+      content = content.slice(agentMatch[0].length);
+    }
+    const tags = [];
+    for (const tagMatch of content.matchAll(TAG_RE)) {
+      const tag = tagMatch[1];
+      if (tag !== undefined && !tags.includes(tag)) {
+        tags.push(tag);
+      }
+    }
+    const summary = content.replace(TAG_RE, "").replace(/\s+/g, " ").trim();
+    if (summary.length === 0) {
+      continue;
+    }
+    const event = {
+      v: EVENT_SCHEMA_VERSION,
+      type: "decision",
+      ts,
+      sessionID,
+      summary
+    };
+    if (agent !== undefined && agent.length > 0) {
+      event.agent = agent;
+    }
+    if (tags.length > 0) {
+      event.tags = tags;
+    }
+    events.push(event);
+    index += 1;
+  }
+  return events;
+}
+
+// src/web/snapshot.ts
+function createSnapshotReader(deps, paths, context = {}) {
+  const readEventsDeps = {
+    listFiles: deps.listFiles,
+    readText: deps.readText,
+    ...paths.legacyTelemetryPath !== undefined ? { legacyTelemetryPath: paths.legacyTelemetryPath } : {}
+  };
+  return async () => {
+    const [sessionEvents, decisionsText, backlogText, agentFiles, lastCommit] = await Promise.all([
+      readSessionEvents(paths.sessionsDir, readEventsDeps),
+      deps.readText(paths.decisionsPath),
+      deps.readText(paths.backlogPath),
+      deps.listAgentFiles(paths.agentDir),
+      deps.gitLastCommit?.() ?? Promise.resolve(undefined)
+    ]);
+    const decisionEvents = parseDecisionsMarkdown(decisionsText ?? "");
+    const events = [...sessionEvents, ...decisionEvents];
+    const team = agentFiles.map(parseAgentFile);
+    const inputs = {
+      generatedAt: deps.now(),
+      events,
+      team
+    };
+    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, ms2) => setTimeout(cb, ms2));
+  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) {
+  return createDashboardRuntime(deps);
+}
+async function createDashboardRuntime(deps) {
+  const backlogPath = deps.backlogPath ?? DEFAULT_BACKLOG_PATH;
+  const decisionsPath = deps.decisionsPath ?? DEFAULT_DECISIONS_PATH;
+  const readSnapshot = createSnapshotReader({
+    readText: deps.readText,
+    listFiles: deps.listFiles,
+    listAgentFiles: deps.listAgentFiles,
+    now: deps.now,
+    ...deps.gitLastCommit !== undefined ? { gitLastCommit: deps.gitLastCommit } : {}
+  }, {
+    sessionsDir: deps.sessionsDir,
+    decisionsPath,
+    backlogPath,
+    agentDir: deps.agentDir,
+    ...deps.legacyTelemetryPath !== undefined ? { legacyTelemetryPath: deps.legacyTelemetryPath } : {}
+  }, {
+    recentRoutesLimit: deps.config.recentRoutes,
+    ...deps.session !== undefined ? { session: deps.session } : {}
+  });
+  const createServer = deps.serve ?? createDashboardServer;
+  const server = await 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.sessionsDir, decisionsPath, backlogPath, deps.agentDir], () => {
+    server.notify();
+  }, { watch: watchFn });
+  return {
+    url: server.url,
+    port: server.port,
+    close() {
+      watcher.close();
+      server.close();
+    }
+  };
+}
+
+// src/cli/dashboardServe.ts
+function parseDashboardServeArgs(rest) {
+  return {
+    status: rest.includes("--status"),
+    serve: rest.includes("--serve"),
+    open: rest.includes("--open")
+  };
+}
+async function runDashboardServe(deps, options) {
+  const config = await deps.loadConfig(deps.configPath);
+  const start = deps.startDashboard ?? startDashboard;
+  let runtime;
+  try {
+    runtime = await start({
+      config: { ...config.dashboard, enabled: true },
+      sessionsDir: deps.sessionsDir,
+      decisionsPath: deps.decisionsPath,
+      backlogPath: deps.backlogPath,
+      agentDir: deps.agentDir,
+      ...deps.legacyTelemetryPath !== undefined ? { legacyTelemetryPath: deps.legacyTelemetryPath } : {},
+      readText: deps.readText,
+      listFiles: deps.listFiles,
+      listAgentFiles: deps.listAgentFiles,
+      now: deps.now,
+      ...deps.gitLastCommit !== undefined ? { gitLastCommit: deps.gitLastCommit } : {},
+      log: deps.log
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    deps.log(`No se pudo iniciar el dashboard: ${message}`);
+    return { exitCode: 1 };
+  }
+  deps.log("Escuchando en loopback. Pulsa Ctrl+C para parar.");
+  if (options.open && deps.openBrowser !== undefined) {
+    try {
+      await deps.openBrowser(runtime.url);
+    } catch {
+      deps.log("No se pudo abrir el navegador automáticamente.");
+    }
+  }
+  await deps.waitForSignal();
+  runtime.close();
+  deps.log("Dashboard detenido.");
+  return { exitCode: 0 };
+}
+
 // src/cli/setupAdapters.ts
 import {
   cancel,
@@ -61,50 +1710,15 @@ var CURATED_FRONTIER_PROFILES = [
     ref: { providerID: "openai", modelID: "gpt-5.3-codex" },
     kind: "frontier",
     contextWindow: 400000,
-    maxOutputTokens: 64000,
-    supportsToolCalling: true,
-    supportsVision: true,
-    reasoningTier: 5,
-    codeQualityTier: 5,
-    costPer1M: { inputUSD: 5, outputUSD: 20 },
-    availability: "available"
-  }
-];
-
-// src/capabilities/types.ts
-import { z } from "zod";
-var CapabilityTierSchema = z.union([
-  z.literal(0),
-  z.literal(1),
-  z.literal(2),
-  z.literal(3),
-  z.literal(4),
-  z.literal(5)
-]);
-var ComplexityTierSchema = z.enum([
-  "trivial",
-  "simple",
-  "moderate",
-  "hard"
-]);
-var ModelCapabilityProfileSchema = z.object({
-  ref: z.object({
-    providerID: z.string().min(1),
-    modelID: z.string().min(1)
-  }),
-  kind: z.enum(["local", "frontier", "router"]),
-  contextWindow: z.number().int().positive(),
-  maxOutputTokens: z.number().int().positive(),
-  supportsToolCalling: z.boolean(),
-  supportsVision: z.boolean(),
-  reasoningTier: CapabilityTierSchema,
-  codeQualityTier: CapabilityTierSchema,
-  costPer1M: z.object({
-    inputUSD: z.number().min(0),
-    outputUSD: z.number().min(0)
-  }),
-  availability: z.enum(["available", "degraded", "unavailable"])
-});
+    maxOutputTokens: 64000,
+    supportsToolCalling: true,
+    supportsVision: true,
+    reasoningTier: 5,
+    codeQualityTier: 5,
+    costPer1M: { inputUSD: 5, outputUSD: 20 },
+    availability: "available"
+  }
+];
 
 // src/capabilities/normalize.ts
 function isRecord(value) {
@@ -735,309 +2349,61 @@ var clackPrompter = {
     return unwrap(result);
   }
 };
-var DETECTION_RUNTIMES = [
-  {
-    id: "ollama",
-    enabled: true,
-    baseURL: "http://localhost:11434/v1",
-    defaultModel: { providerID: "ollama", modelID: "probe" }
-  },
-  {
-    id: "lmstudio",
-    enabled: true,
-    baseURL: "http://localhost:1234/v1",
-    defaultModel: { providerID: "lmstudio", modelID: "probe" }
-  },
-  {
-    id: "foundry-local",
-    enabled: true,
-    discovery: "cli",
-    defaultModel: { providerID: "foundry-local", modelID: "probe" }
-  }
-];
-function createLoadFrontierProfiles() {
-  return async () => {
-    try {
-      const result = await loadCapabilityProfiles({
-        fetch: globalThis.fetch,
-        now: () => Date.now()
-      });
-      return result.profiles.length > 0 ? result.profiles : [...CURATED_FRONTIER_PROFILES];
-    } catch {
-      return [...CURATED_FRONTIER_PROFILES];
-    }
-  };
-}
-function createDetect(exec) {
-  return async () => {
-    const registry = new RuntimeRegistry({
-      fetch: globalThis.fetch,
-      clock: () => new Date().toISOString(),
-      foundryDiscovery: foundryDiscoveryFromExec(exec)
-    });
-    const snapshots = await registry.probe(DETECTION_RUNTIMES);
-    return snapshots.map((snapshot) => {
-      const detected = {
-        id: snapshot.id,
-        baseURL: snapshot.baseURL,
-        reachable: snapshot.reachable,
-        models: snapshot.models.map((model) => model.modelID)
-      };
-      if (snapshot.error !== undefined) {
-        detected.error = snapshot.error;
-      }
-      return detected;
-    });
-  };
-}
-
-// src/commands/agents.ts
-var PROVIDER_LABELS = {
-  "github-copilot": "GitHub Copilot",
-  anthropic: "Anthropic",
-  openai: "OpenAI",
-  google: "Google",
-  openrouter: "OpenRouter",
-  ollama: "Ollama",
-  lmstudio: "LM Studio",
-  "foundry-local": "Foundry Local"
-};
-function providerLabel(providerID) {
-  return PROVIDER_LABELS[providerID] ?? providerID;
-}
-function unquote(value) {
-  const trimmed = value.trim();
-  if (trimmed.length >= 2 && (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
-function parseModelValue(value) {
-  const raw = unquote(value);
-  const slash = raw.indexOf("/");
-  if (slash <= 0 || slash === raw.length - 1) {
-    return;
-  }
-  return { providerID: raw.slice(0, slash), modelID: raw.slice(slash + 1) };
-}
-function parseAgentFile(file) {
-  const info = { name: file.name, mode: "subagent" };
-  const lines = file.contents.split(/\r?\n/);
-  if (lines[0]?.trim() !== "---") {
-    return info;
-  }
-  for (let i = 1;i < lines.length; i += 1) {
-    const line = lines[i] ?? "";
-    if (line.trim() === "---") {
-      break;
-    }
-    const colon = line.indexOf(":");
-    if (colon <= 0) {
-      continue;
-    }
-    const key = line.slice(0, colon).trim();
-    const value = line.slice(colon + 1).trim();
-    if (key === "mode") {
-      info.mode = unquote(value) || "subagent";
-    } else if (key === "description") {
-      info.description = unquote(value);
-    } else if (key === "model") {
-      const model = parseModelValue(value);
-      if (model !== undefined) {
-        info.model = model;
-      }
-    }
-  }
-  return info;
-}
-function localProviderIDs(config) {
-  const ids = new Set;
-  for (const runtime of config.local.runtimes) {
-    ids.add(runtime.id);
-    ids.add(runtime.defaultModel.providerID);
-  }
-  ids.add(config.router.localDefault.providerID);
-  return ids;
-}
-function subscriptionLabel(model, localProviders) {
-  const isLocal = localProviders.has(model.providerID);
-  if (isLocal) {
-    return {
-      kind: "local",
-      subscription: `local · ${providerLabel(model.providerID)} (sin coste de tokens)`
-    };
-  }
-  return {
-    kind: "frontier",
-    subscription: `frontier · ${providerLabel(model.providerID)} (consume tu suscripción)`
-  };
-}
-function classifyAgent(info, context) {
-  if (info.model !== undefined) {
-    const { kind, subscription: subscription2 } = subscriptionLabel(info.model, context.localProviders);
-    return {
-      name: info.name,
-      mode: info.mode,
-      kind,
-      model: info.model,
-      subscription: subscription2
-    };
-  }
-  if (context.defaultModel === undefined) {
-    return {
-      name: info.name,
-      mode: info.mode,
-      kind: "inherited",
-      subscription: "hereda el default de opencode.json (sin definir) · openteam enruta local-first por mensaje"
-    };
-  }
-  const { subscription } = subscriptionLabel(context.defaultModel, context.localProviders);
-  return {
-    name: info.name,
-    mode: info.mode,
-    kind: "inherited",
-    model: context.defaultModel,
-    subscription: `hereda default → ${subscription} · openteam enruta local-first por mensaje`
-  };
-}
-function modeRank(mode) {
-  if (mode === "primary") {
-    return 0;
-  }
-  if (mode === "all") {
-    return 1;
-  }
-  return 2;
-}
-function classifyAgents(files, context) {
-  return files.map((file) => classifyAgent(parseAgentFile(file), context)).sort((a, b) => {
-    const rank = modeRank(a.mode) - modeRank(b.mode);
-    return rank !== 0 ? rank : a.name.localeCompare(b.name);
-  });
-}
-function modelText(classification) {
-  return classification.model === undefined ? "" : ` (${classification.model.providerID}/${classification.model.modelID})`;
-}
-function renderAgentList(classifications, context) {
-  const lines = ["openteam agents — LLM por agente:", ""];
-  if (classifications.length === 0) {
-    lines.push("  (sin agentes en .opencode/agent/) — ejecuta 'openteam setup' o pide al orquestador que cree el equipo.");
-    return lines.join(`
-`);
-  }
-  const nameWidth = Math.max(...classifications.map((c) => c.name.length), "agente".length);
-  const modeWidth = Math.max(...classifications.map((c) => c.mode.length), "subagent".length);
-  for (const c of classifications) {
-    const bullet = c.mode === "primary" ? "●" : "○";
-    lines.push(`  ${bullet} ${c.name.padEnd(nameWidth)}  [${c.mode.padEnd(modeWidth)}]  ${c.subscription}${modelText(c)}`);
-  }
-  lines.push("");
-  if (context.defaultModel !== undefined) {
-    const { kind } = subscriptionLabel(context.defaultModel, context.localProviders);
-    lines.push(`Default de opencode.json: ${context.defaultModel.providerID}/${context.defaultModel.modelID} (${kind} · ${providerLabel(context.defaultModel.providerID)})`);
-  } else {
-    lines.push("Default de opencode.json: (sin definir)");
-  }
-  lines.push("Leyenda: ● primary · ○ subagent · local = sin coste de tokens · frontier = consume tu suscripción.");
-  return lines.join(`
-`);
-}
-
-// src/config/schema.ts
-import { z as z2 } from "zod";
-var ModelRefSchema = z2.object({
-  providerID: z2.string().min(1),
-  modelID: z2.string().min(1)
-});
-var RouterModeSchema = z2.enum(["economy", "balanced", "quality"]);
-var PrivacyModeSchema = z2.enum([
-  "forceLocalOnSensitive",
-  "consentBeforeFrontier",
-  "off"
-]);
-var BaselineModeSchema = z2.enum(["auto", "pinned"]);
-var DashboardHostSchema = z2.enum(["127.0.0.1", "localhost"]);
-var DashboardConfigSchema = z2.object({
-  enabled: z2.boolean().default(false),
-  host: DashboardHostSchema.default("127.0.0.1"),
-  port: z2.number().int().min(1024).max(65535).default(4599),
-  autoPortFallback: z2.boolean().default(true),
-  refreshMs: z2.number().int().min(250).default(2000),
-  recentRoutes: z2.number().int().positive().default(50),
-  openBrowser: z2.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"
-};
-var defaultFrontierModel = {
-  providerID: "anthropic",
-  modelID: "claude-sonnet-4-5"
-};
-var LocalRuntimeSchema = z2.object({
-  id: z2.enum(["ollama", "lmstudio", "foundry-local"]),
-  enabled: z2.boolean().default(true),
-  baseURL: z2.string().url().optional(),
-  discovery: z2.enum(["cli", "sdk", "manual"]).optional(),
-  defaultModel: ModelRefSchema
-});
-var OpenTeamConfigSchema = z2.object({
-  baseline: z2.object({
-    mode: BaselineModeSchema.default("auto"),
-    pinnedModel: ModelRefSchema.nullable().default(null),
-    hardDefault: ModelRefSchema.default(defaultFrontierModel)
-  }).default({
-    mode: "auto",
-    pinnedModel: null,
-    hardDefault: defaultFrontierModel
-  }),
-  router: z2.object({
-    mode: RouterModeSchema.default("balanced"),
-    localDefault: ModelRefSchema.default(defaultLocalModel),
-    trivialPromptMaxChars: z2.number().int().positive().default(280),
-    frontierPromptMinChars: z2.number().int().positive().default(2000)
-  }).default({
-    mode: "balanced",
-    localDefault: defaultLocalModel,
-    trivialPromptMaxChars: 280,
-    frontierPromptMinChars: 2000
-  }),
-  local: z2.object({
-    runtimes: z2.array(LocalRuntimeSchema).min(1).default([
-      {
-        id: "ollama",
-        enabled: true,
-        baseURL: "http://localhost:11434/v1",
-        defaultModel: { providerID: "ollama", modelID: "qwen3:8b" }
-      }
-    ])
-  }).default({
-    runtimes: [
-      {
-        id: "ollama",
-        enabled: true,
-        baseURL: "http://localhost:11434/v1",
-        defaultModel: defaultLocalModel
+var DETECTION_RUNTIMES = [
+  {
+    id: "ollama",
+    enabled: true,
+    baseURL: "http://localhost:11434/v1",
+    defaultModel: { providerID: "ollama", modelID: "probe" }
+  },
+  {
+    id: "lmstudio",
+    enabled: true,
+    baseURL: "http://localhost:1234/v1",
+    defaultModel: { providerID: "lmstudio", modelID: "probe" }
+  },
+  {
+    id: "foundry-local",
+    enabled: true,
+    discovery: "cli",
+    defaultModel: { providerID: "foundry-local", modelID: "probe" }
+  }
+];
+function createLoadFrontierProfiles() {
+  return async () => {
+    try {
+      const result = await loadCapabilityProfiles({
+        fetch: globalThis.fetch,
+        now: () => Date.now()
+      });
+      return result.profiles.length > 0 ? result.profiles : [...CURATED_FRONTIER_PROFILES];
+    } catch {
+      return [...CURATED_FRONTIER_PROFILES];
+    }
+  };
+}
+function createDetect(exec) {
+  return async () => {
+    const registry = new RuntimeRegistry({
+      fetch: globalThis.fetch,
+      clock: () => new Date().toISOString(),
+      foundryDiscovery: foundryDiscoveryFromExec(exec)
+    });
+    const snapshots = await registry.probe(DETECTION_RUNTIMES);
+    return snapshots.map((snapshot) => {
+      const detected = {
+        id: snapshot.id,
+        baseURL: snapshot.baseURL,
+        reachable: snapshot.reachable,
+        models: snapshot.models.map((model) => model.modelID)
+      };
+      if (snapshot.error !== undefined) {
+        detected.error = snapshot.error;
       }
-    ]
-  }),
-  budgets: z2.object({
-    sessionUSD: z2.number().positive().optional(),
-    monthlyUSD: z2.number().positive().optional(),
-    frontierTokensPerSession: z2.number().int().positive().optional(),
-    hardStopOnBudgetExhaustion: z2.boolean().default(false)
-  }).default({ hardStopOnBudgetExhaustion: false }),
-  privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
-  dashboard: DashboardConfigSchema
-});
+      return detected;
+    });
+  };
+}
 
 // src/commands/baseline.ts
 function formatRef(ref) {
@@ -1103,25 +2469,19 @@ 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.",
+    "Dashboard (multi-sesión, se lanza desde la CLI):",
     `  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."
+    "Lánzalo con:",
+    "  openteam dashboard                (Ctrl+C para parar; --open abre el navegador)",
+    "",
+    "Agrega TODAS las sesiones de opencode que escriben eventos en",
+    "  .opencode/openteam/sessions/*.jsonl",
+    "Solo escucha en loopback y nunca expone prompts (solo hashes)."
   ].join(`
 `);
 }
@@ -1258,7 +2618,12 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "- **scribe** — memoria silenciosa del equipo. Registra decisiones y",
     "  aprendizajes en un log compartido (`.opencode/openteam-decisions.md`) sin",
     "  ejecutar cambios de código. Modelo **local**; permisos de solo lectura más",
-    "  edición de ese log.",
+    "  edición de ese log. **Formato parseable** para el dashboard: una decisión",
+    "  por línea como item de lista Markdown, ya **redactada** (sin prompts ni",
+    "  datos sensibles):",
+    "  `- YYYY-MM-DD [agente] Resumen breve de la decisión #tag1 #tag2`",
+    "  La fecha, el `[agente]` y los `#tags` son opcionales; el resumen es",
+    "  obligatorio.",
     "- **ralph** — automatización y triage. Monitoriza el trabajo pendiente",
     "  (issues/tareas), lo prioriza, coordina la ejecución delegando en los",
     "  especialistas y **escala al humano** ante bloqueos, riesgos o aprobaciones.",
@@ -1341,78 +2706,6 @@ function buildOrchestratorAgent(frontier, options = {}) {
 ${body}`;
 }
 
-// src/commands/report.ts
-var TIERS = [
-  "trivial",
-  "simple",
-  "moderate",
-  "hard"
-];
-function emptyTierSummary() {
-  return {
-    trivial: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
-    simple: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
-    moderate: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
-    hard: { count: 0, estimatedUSD: 0, savingsUSD: 0 }
-  };
-}
-function summarizeCostRecords(records) {
-  const report = {
-    count: 0,
-    localCount: 0,
-    frontierCount: 0,
-    totalEstimatedUSD: 0,
-    totalBaselineUSD: 0,
-    totalSavingsUSD: 0,
-    savingsPct: 0,
-    tokensIn: 0,
-    tokensOut: 0,
-    byTier: emptyTierSummary()
-  };
-  for (const record of records) {
-    report.count += 1;
-    if (record.routeKind === "local") {
-      report.localCount += 1;
-    } else {
-      report.frontierCount += 1;
-    }
-    report.totalEstimatedUSD += record.estimatedCostUSD;
-    report.totalBaselineUSD += record.baselineCostUSD;
-    report.totalSavingsUSD += record.estimatedSavingsUSD;
-    report.tokensIn += record.tokensIn ?? 0;
-    report.tokensOut += record.tokensOut ?? 0;
-    const tier = report.byTier[record.tier];
-    tier.count += 1;
-    tier.estimatedUSD += record.estimatedCostUSD;
-    tier.savingsUSD += record.estimatedSavingsUSD;
-  }
-  report.savingsPct = report.totalBaselineUSD > 0 ? report.totalSavingsUSD / report.totalBaselineUSD * 100 : 0;
-  return report;
-}
-function usd(value) {
-  return `$${value.toFixed(5)}`;
-}
-function renderReport(report) {
-  if (report.count === 0) {
-    return "openteam report: sin registros de telemetría todavía.";
-  }
-  const lines = [
-    "openteam report:",
-    `  decisiones:   ${report.count} (local ${report.localCount} · frontier ${report.frontierCount})`,
-    `  coste real:   ${usd(report.totalEstimatedUSD)}`,
-    `  baseline:     ${usd(report.totalBaselineUSD)}`,
-    `  ahorro:       ${usd(report.totalSavingsUSD)} (${report.savingsPct.toFixed(2)}%)`,
-    `  tokens:       in ${report.tokensIn} · out ${report.tokensOut}`,
-    "  por tier:"
-  ];
-  for (const tier of TIERS) {
-    const summary = report.byTier[tier];
-    lines.push(`    ${tier.padEnd(9)} ${summary.count} · coste ${usd(summary.estimatedUSD)} · ahorro ${usd(summary.savingsUSD)}`);
-  }
-  return lines.join(`
-`);
-}
-
 // src/commands/yolo.ts
 var CATCH_ALL = "*";
 var ALLOW = "allow";
@@ -1460,7 +2753,8 @@ 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 dashboard                Lanza el dashboard web multi-sesión (Ctrl+C para parar; --open abre el navegador)",
+  "  openteam dashboard --status       Muestra la config del dashboard sin lanzarlo",
   "  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)",
@@ -2123,71 +3417,29 @@ function loadOpenTeamConfig(raw) {
   return OpenTeamConfigSchema.parse(raw ?? {});
 }
 
-// src/telemetry/read.ts
-import { readFile } from "node:fs/promises";
-
-// src/telemetry/types.ts
-import { z as z3 } from "zod";
-var CostRecordSchema = z3.object({
-  ts: z3.number().finite(),
-  sessionID: z3.string().min(1).optional(),
-  promptHash: z3.string().min(1),
-  promptChars: z3.number().int().min(0),
-  tier: ComplexityTierSchema,
-  routeKind: z3.enum(["local", "frontier"]),
-  selected: ModelRefSchema,
-  rationale: z3.string(),
-  estimatedCostUSD: z3.number().finite().min(0),
-  baselineCostUSD: z3.number().finite().min(0),
-  estimatedSavingsUSD: z3.number().finite(),
-  budgetAction: z3.string().min(1),
-  tokensIn: z3.number().int().min(0).optional(),
-  tokensOut: z3.number().int().min(0).optional()
-});
-
-// src/telemetry/read.ts
-var DEFAULT_TELEMETRY_PATH = ".opencode/openteam-telemetry.jsonl";
-function parseCostRecordsJsonl(text2) {
-  const records = [];
-  for (const line of text2.split(`
-`)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    let candidate;
-    try {
-      candidate = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    const parsed = CostRecordSchema.safeParse(candidate);
-    if (parsed.success) {
-      records.push(parsed.data);
+// src/web/git.ts
+function createGitLastCommit(exec) {
+  return async () => {
+    const output = await exec("git", [
+      "log",
+      "-1",
+      "--pretty=format:%h%x1f%s%x1f%cI"
+    ]);
+    if (output.exitCode !== 0) {
+      return;
     }
-  }
-  return records;
-}
-function isMissingFile(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-async function readCostRecords(path, deps = {}) {
-  const readFileFn = deps.readFile ?? readFile;
-  try {
-    const content = await readFileFn(path, "utf8");
-    return parseCostRecordsJsonl(content);
-  } catch (error) {
-    if (isMissingFile(error)) {
-      return [];
+    const [hash, subject, at] = output.stdout.trim().split("\x1F");
+    if (hash === undefined || subject === undefined || at === undefined) {
+      return;
     }
-    throw error;
-  }
+    return { hash, subject, at };
+  };
 }
 
 // src/cli.ts
 var execFileAsync = promisify(execFile);
 var AGENT_DIR = dirname2(ORCHESTRATOR_AGENT_PATH);
-function isMissingFile2(error) {
+function isMissingFile(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 var nodeExec = async (command, args) => {
@@ -2205,24 +3457,60 @@ var nodeExec = async (command, args) => {
 };
 async function loadConfig(path) {
   try {
-    const content = await readFile2(path, "utf8");
+    const content = await readFile(path, "utf8");
     return loadOpenTeamConfig(JSON.parse(content));
   } catch (error) {
-    if (isMissingFile2(error)) {
+    if (isMissingFile(error)) {
       return loadOpenTeamConfig({});
     }
     throw error;
   }
 }
+async function readTextOptional(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+async function listDirFiles(dir) {
+  try {
+    return await readdir(dir);
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+async function openBrowser(url) {
+  if (process.platform === "win32") {
+    await nodeExec("cmd", ["/c", "start", "", url]);
+  } else if (process.platform === "darwin") {
+    await nodeExec("open", [url]);
+  } else {
+    await nodeExec("xdg-open", [url]);
+  }
+}
+function waitForSignal() {
+  return new Promise((resolve) => {
+    const done = () => resolve();
+    process.once("SIGINT", done);
+    process.once("SIGTERM", done);
+  });
+}
 var deps = {
   loadConfig,
   saveConfig: (config, path) => writeOpenTeamConfigFile(config, path),
   readOpencodeConfig: async (path) => {
     try {
-      const content = await readFile2(path, "utf8");
+      const content = await readFile(path, "utf8");
       return JSON.parse(content);
     } catch (error) {
-      if (isMissingFile2(error)) {
+      if (isMissingFile(error)) {
         return;
       }
       throw error;
@@ -2242,7 +3530,7 @@ var deps = {
     try {
       entries = await readdir(dir);
     } catch (error) {
-      if (isMissingFile2(error)) {
+      if (isMissingFile(error)) {
         return [];
       }
       throw error;
@@ -2250,7 +3538,7 @@ var deps = {
     const mdFiles = entries.filter((entry) => entry.endsWith(".md"));
     return Promise.all(mdFiles.map(async (entry) => ({
       name: entry.replace(/\.md$/, ""),
-      contents: await readFile2(join2(dir, entry), "utf8")
+      contents: await readFile(join2(dir, entry), "utf8")
     })));
   },
   probe: (config) => {
@@ -2261,7 +3549,11 @@ var deps = {
     });
     return registry.probe(config.local.runtimes);
   },
-  readTelemetry: (path) => readCostRecords(path),
+  readTelemetry: (path) => readRouteCostRecords(DEFAULT_SESSIONS_DIR, {
+    listFiles: listDirFiles,
+    readText: readTextOptional,
+    legacyTelemetryPath: path
+  }),
   configPath: DEFAULT_CONFIG_PATH,
   telemetryPath: DEFAULT_TELEMETRY_PATH,
   opencodeConfigPath: OPENCODE_CONFIG_PATH,
@@ -2299,6 +3591,31 @@ async function main() {
     process.exitCode = result2.exitCode;
     return;
   }
+  if (argv[0] === "dashboard") {
+    const flags = parseDashboardServeArgs(argv.slice(1));
+    if (!flags.status) {
+      const result2 = await runDashboardServe({
+        loadConfig,
+        configPath: DEFAULT_CONFIG_PATH,
+        sessionsDir: DEFAULT_SESSIONS_DIR,
+        decisionsPath: DEFAULT_DECISIONS_PATH,
+        backlogPath: DEFAULT_BACKLOG_PATH,
+        agentDir: AGENT_DIR,
+        legacyTelemetryPath: DEFAULT_TELEMETRY_PATH,
+        readText: readTextOptional,
+        listFiles: listDirFiles,
+        listAgentFiles: deps.listAgentFiles,
+        now: () => new Date().toISOString(),
+        gitLastCommit: createGitLastCommit(nodeExec),
+        waitForSignal,
+        log: (message) => process.stdout.write(`${message}
+`),
+        openBrowser
+      }, { open: flags.open });
+      process.exitCode = result2.exitCode;
+      return;
+    }
+  }
   const result = await runCli(argv, deps);
   process.stdout.write(`${result.stdout}
 `);