@jmanuelcorral/openteam 0.1.21 → 0.1.23

package/dist/cli.js

@@ -2,31 +2,16 @@
 
 // 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/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/web/paths.ts
 var DEFAULT_BACKLOG_PATH = ".opencode/openteam-backlog.md";
+var DEFAULT_DECISIONS_PATH = ".opencode/openteam-decisions.md";
 
 // src/web/server.ts
 import {
@@ -49,6 +34,12 @@ function usd(value) {
 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}`;
 }
@@ -169,6 +160,101 @@ function activityPanel(activity) {
     "</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}
@@ -198,6 +284,7 @@ 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}
 `;
@@ -224,10 +311,14 @@ 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)}`;
@@ -307,21 +398,602 @@ 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)}`);
+  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 lines.join(`
-`);
+  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
@@ -375,6 +1047,8 @@ function buildLoopSnapshot(backlogPath, 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,
@@ -387,11 +1061,49 @@ function toRouteView(record) {
     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 recentActivity(entries, limit) {
-  return [...entries].sort((a, b) => b.ts - a.ts).slice(0, Math.max(0, limit));
+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) {
@@ -406,13 +1118,21 @@ function loopFrom(backlog) {
 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(inputs.costRecords),
-    recentRoutes: recentRoutes(inputs.costRecords, recentRoutesLimit),
+    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: recentActivity(inputs.activity, activityLimit)
+    activity: activityFeed(aggregate, activityLimit)
   };
   if (inputs.session?.id !== undefined) {
     state.session.id = inputs.session.id;
@@ -703,216 +1423,95 @@ function renderAgentList(classifications, context) {
 `);
 }
 
-// src/telemetry/read.ts
-import { readFile } from "node:fs/promises";
-
-// src/telemetry/types.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/types.ts
-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(text) {
-  const records = [];
+// 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 trimmed = line.trim();
-    if (trimmed.length === 0) {
+    const bullet = BULLET_RE.exec(line);
+    if (bullet === null) {
       continue;
     }
-    let candidate;
-    try {
-      candidate = JSON.parse(trimmed);
-    } catch {
+    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 parsed = CostRecordSchema.safeParse(candidate);
-    if (parsed.success) {
-      records.push(parsed.data);
+    const event = {
+      v: EVENT_SCHEMA_VERSION,
+      type: "decision",
+      ts,
+      sessionID,
+      summary
+    };
+    if (agent !== undefined && agent.length > 0) {
+      event.agent = agent;
     }
-  }
-  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 [];
+    if (tags.length > 0) {
+      event.tags = tags;
     }
-    throw error;
+    events.push(event);
+    index += 1;
   }
+  return events;
 }
 
 // src/web/snapshot.ts
-function createSnapshotReader(deps, paths, context) {
+function createSnapshotReader(deps, paths, context = {}) {
+  const readEventsDeps = {
+    listFiles: deps.listFiles,
+    readText: deps.readText,
+    ...paths.legacyTelemetryPath !== undefined ? { legacyTelemetryPath: paths.legacyTelemetryPath } : {}
+  };
   return async () => {
-    const [telemetryText, backlogText, agentFiles, lastCommit] = await Promise.all([
-      deps.readText(paths.telemetryPath),
+    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 costRecords = parseCostRecordsJsonl(telemetryText ?? "");
+    const decisionEvents = parseDecisionsMarkdown(decisionsText ?? "");
+    const events = [...sessionEvents, ...decisionEvents];
     const team = agentFiles.map(parseAgentFile);
     const inputs = {
       generatedAt: deps.now(),
-      costRecords,
-      team,
-      activity: context.activity()
+      events,
+      team
     };
     if (backlogText !== undefined) {
       const backlog = {
@@ -936,7 +1535,7 @@ function createSnapshotReader(deps, paths, context) {
 
 // src/web/watch.ts
 function watchSources(paths, onChange, deps, debounceMs = 250) {
-  const setTimer = deps.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
+  const setTimer = deps.setTimer ?? ((cb, ms2) => setTimeout(cb, ms2));
   const clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
   const watchers = [];
   let pending;
@@ -973,18 +1572,20 @@ function startDashboard(deps) {
 }
 async function createDashboardRuntime(deps) {
   const backlogPath = deps.backlogPath ?? DEFAULT_BACKLOG_PATH;
-  const activity = createActivityBuffer(deps.config.recentRoutes);
+  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 } : {}
   }, {
-    telemetryPath: deps.telemetryPath,
+    sessionsDir: deps.sessionsDir,
+    decisionsPath,
     backlogPath,
-    agentDir: deps.agentDir
+    agentDir: deps.agentDir,
+    ...deps.legacyTelemetryPath !== undefined ? { legacyTelemetryPath: deps.legacyTelemetryPath } : {}
   }, {
-    activity: () => activity.list(),
     recentRoutesLimit: deps.config.recentRoutes,
     ...deps.session !== undefined ? { session: deps.session } : {}
   });
@@ -995,16 +1596,12 @@ async function createDashboardRuntime(deps) {
     ...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], () => {
+  const watcher = watchSources([deps.sessionsDir, decisionsPath, 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();
@@ -1015,6 +1612,7 @@ async function createDashboardRuntime(deps) {
 // src/cli/dashboardServe.ts
 function parseDashboardServeArgs(rest) {
   return {
+    status: rest.includes("--status"),
     serve: rest.includes("--serve"),
     open: rest.includes("--open")
   };
@@ -1026,10 +1624,13 @@ async function runDashboardServe(deps, options) {
   try {
     runtime = await start({
       config: { ...config.dashboard, enabled: true },
-      telemetryPath: deps.telemetryPath,
+      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 } : {},
@@ -1868,29 +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 dentro de opencode, pon "dashboard": { "enabled": true }',
-      "en .opencode/openteam.json y recarga opencode. Se servirá (loopback) en:",
-      `  ${url}`,
-      "",
-      "O véelo ahora mismo sin editar la config:",
-      "  openteam dashboard --serve        (añade --open para abrir el navegador)"
-    ].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.",
-    "Para verlo fuera de opencode: openteam dashboard --serve"
+    "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(`
 `);
 }
@@ -2027,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.",
@@ -2157,8 +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 --serve        Levanta el dashboard web (Ctrl+C para parar; --open abre el navegador)",
+  "  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)",
@@ -2387,13 +2983,21 @@ async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, deps
 }
 
 // src/commands/slashCommand.ts
-var OPENTEAM_COMMAND_PATH = ".opencode/command/openteam.md";
-function buildOpenteamCommand() {
+var OPENTEAM_COMMAND_DIR = ".opencode/command";
+var OPENTEAM_COMMAND_PATH = `${OPENTEAM_COMMAND_DIR}/openteam.md`;
+function renderCommand(description, body) {
+  return ["---", `description: ${description}`, "---", "", body, ""].join(`
+`);
+}
+function fixedActionBody(action) {
   return [
-    "---",
-    "description: Comandos runtime de openteam (baseline show|set|auto, doctor, agents, dashboard, report)",
-    "---",
-    "",
+    `Llama a la herramienta \`openteam\` una sola vez con \`action: "${action}"\`.`,
+    "Devuelve su salida tal cual, sin reinterpretarla."
+  ].join(`
+`);
+}
+function buildOpenteamCommand() {
+  return renderCommand("Comandos runtime de openteam (baseline show|set|auto, doctor, agents, dashboard, report)", [
     "Usa la herramienta `openteam` para ejecutar el comando indicado por el usuario: $ARGUMENTS",
     "",
     "Interpreta los argumentos así y llama a la herramienta `openteam` una sola vez:",
@@ -2406,10 +3010,36 @@ function buildOpenteamCommand() {
     '- `dashboard` → `action: "dashboard"`',
     '- `report` → `action: "report"`',
     "",
-    "Devuelve la salida de la herramienta tal cual, sin reinterpretarla.",
-    ""
+    "Devuelve la salida de la herramienta tal cual, sin reinterpretarla."
   ].join(`
-`);
+`));
+}
+function buildBaselineCommand() {
+  return renderCommand("openteam · baseline frontier cheapest-capable (show | set <provider/model> | auto)", [
+    "Usa la herramienta `openteam` para el baseline frontier: $ARGUMENTS",
+    "",
+    '- vacío o `show` → `action: "show"`',
+    '- `set <provider/model>` → `action: "set"`, `model: "<provider/model>"`',
+    '- `auto` → `action: "auto"`',
+    "",
+    "Llama a la herramienta una sola vez y devuelve su salida tal cual."
+  ].join(`
+`));
+}
+function buildOpenteamCommands() {
+  const file = (name, contents) => ({
+    name,
+    path: `${OPENTEAM_COMMAND_DIR}/${name}.md`,
+    contents
+  });
+  return [
+    file("openteam", buildOpenteamCommand()),
+    file("openteam-baseline", buildBaselineCommand()),
+    file("openteam-doctor", renderCommand("openteam · diagnóstico de runtimes locales y configuración", fixedActionBody("doctor"))),
+    file("openteam-agents", renderCommand("openteam · lista los agentes y el LLM (local/frontier + suscripción) de cada uno", fixedActionBody("agents"))),
+    file("openteam-dashboard", renderCommand("openteam · estado y URL del dashboard web multi-sesión", fixedActionBody("dashboard"))),
+    file("openteam-report", renderCommand("openteam · resumen de coste/ahorro (telemetría)", fixedActionBody("report")))
+  ];
 }
 
 // src/commands/setup.ts
@@ -2759,11 +3389,10 @@ async function runSetup(deps) {
     const openTeamConfig = buildOpenTeamConfig(answers);
     const opencodeConfig = buildOpencodeConfig(answers);
     const orchestratorAgent = buildOrchestratorAgent(frontier, { yolo });
-    const slashCommand = buildOpenteamCommand();
+    const slashCommands = buildOpenteamCommands();
     const openTeamPath = join(deps.cwd, DEFAULT_CONFIG_PATH);
     const opencodePath = join(deps.cwd, OPENCODE_CONFIG_PATH);
     const agentPath = join(deps.cwd, ORCHESTRATOR_AGENT_PATH);
-    const commandPath = join(deps.cwd, OPENTEAM_COMMAND_PATH);
     const existing = [];
     if (await deps.fileExists(openTeamPath)) {
       existing.push(DEFAULT_CONFIG_PATH);
@@ -2774,8 +3403,10 @@ async function runSetup(deps) {
     if (await deps.fileExists(agentPath)) {
       existing.push(ORCHESTRATOR_AGENT_PATH);
     }
-    if (await deps.fileExists(commandPath)) {
-      existing.push(OPENTEAM_COMMAND_PATH);
+    for (const command of slashCommands) {
+      if (await deps.fileExists(join(deps.cwd, command.path))) {
+        existing.push(command.path);
+      }
     }
     if (existing.length > 0) {
       const overwrite = await prompt.confirm({
@@ -2790,25 +3421,27 @@ async function runSetup(deps) {
     await deps.writeFile(openTeamPath, serializeOpenTeamConfig(openTeamConfig));
     await deps.writeFile(opencodePath, serializeOpencodeConfig(opencodeConfig));
     await deps.writeFile(agentPath, orchestratorAgent);
-    await deps.writeFile(commandPath, slashCommand);
+    for (const command of slashCommands) {
+      await deps.writeFile(join(deps.cwd, command.path), command.contents);
+    }
     const enabledSummary = runtimes.filter((runtime) => runtime.enabled).map((runtime) => `${runtime.id} (${runtime.defaultModelID})`).join(", ");
     prompt.note([
       `Baseline frontier: ${frontier.providerID}/${frontier.modelID}`,
       `Runtimes locales: ${enabledSummary || "ninguno habilitado"}`,
       `Modo YOLO: ${yolo ? "activado (auto-aprueba permisos)" : "desactivado"}`,
       `Dashboard web: ${dashboard ? "activado (http://127.0.0.1:4599 mientras opencode esté abierto)" : "desactivado"}`,
-      `Escrito: ${OPENCODE_CONFIG_PATH}, ${DEFAULT_CONFIG_PATH}, ${ORCHESTRATOR_AGENT_PATH}, ${OPENTEAM_COMMAND_PATH}`,
+      `Escrito: ${OPENCODE_CONFIG_PATH}, ${DEFAULT_CONFIG_PATH}, ${ORCHESTRATOR_AGENT_PATH}, ${OPENTEAM_COMMAND_DIR}/*.md (${slashCommands.length} comandos)`,
       "",
       "Siguientes pasos:",
       `  1. Autentica el provider frontier: opencode auth login`,
       reachableIds.length === 0 ? "  2. Arranca tu runtime local (Ollama/LM Studio/Foundry) antes de usarlo" : "  2. Abre opencode en este repo; openteam enruta local-first automáticamente",
-      "  3. Pulsa Tab y elige el agente 'openteam', o usa el slash command /openteam"
+      "  3. Pulsa Tab y elige el agente 'openteam', o teclea / y elige un comando /openteam…"
     ].join(`
 `), "openteam configurado");
     prompt.outro("Listo. Abre opencode y selecciona el agente 'openteam'.");
     return {
       exitCode: 0,
-      stdout: `openteam setup completado: ${OPENCODE_CONFIG_PATH}, ${DEFAULT_CONFIG_PATH}, ${ORCHESTRATOR_AGENT_PATH}, ${OPENTEAM_COMMAND_PATH}`
+      stdout: `openteam setup completado: ${OPENCODE_CONFIG_PATH}, ${DEFAULT_CONFIG_PATH}, ${ORCHESTRATOR_AGENT_PATH}, ${OPENTEAM_COMMAND_DIR}/*.md`
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -2843,7 +3476,7 @@ function createGitLastCommit(exec) {
 // 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) => {
@@ -2861,10 +3494,10 @@ 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;
@@ -2872,14 +3505,24 @@ async function loadConfig(path) {
 }
 async function readTextOptional(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile(path, "utf8");
   } catch (error) {
-    if (isMissingFile2(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]);
@@ -2901,10 +3544,10 @@ var deps = {
   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;
@@ -2924,7 +3567,7 @@ var deps = {
     try {
       entries = await readdir(dir);
     } catch (error) {
-      if (isMissingFile2(error)) {
+      if (isMissingFile(error)) {
         return [];
       }
       throw error;
@@ -2932,7 +3575,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) => {
@@ -2943,7 +3586,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,
@@ -2983,14 +3630,17 @@ async function main() {
   }
   if (argv[0] === "dashboard") {
     const flags = parseDashboardServeArgs(argv.slice(1));
-    if (flags.serve) {
+    if (!flags.status) {
       const result2 = await runDashboardServe({
         loadConfig,
         configPath: DEFAULT_CONFIG_PATH,
-        telemetryPath: DEFAULT_TELEMETRY_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),