@jmanuelcorral/openteam 0.1.20 → 0.1.22

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   appendFile,
   mkdir as mkdir2,
   readdir,
-  readFile as readFile2,
+  readFile,
   writeFile as writeFile2
 } from "node:fs/promises";
 import { dirname as dirname2, join } from "node:path";
@@ -110,7 +110,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.",
@@ -751,6 +756,201 @@ function createAvailabilityCache(options) {
   };
 }
 
+// src/telemetry/events.ts
+import { z as z3 } from "zod";
+
+// src/capabilities/types.ts
+import { z as z2 } from "zod";
+var CapabilityTierSchema = z2.union([
+  z2.literal(0),
+  z2.literal(1),
+  z2.literal(2),
+  z2.literal(3),
+  z2.literal(4),
+  z2.literal(5)
+]);
+var ComplexityTierSchema = z2.enum([
+  "trivial",
+  "simple",
+  "moderate",
+  "hard"
+]);
+var ModelCapabilityProfileSchema = z2.object({
+  ref: z2.object({
+    providerID: z2.string().min(1),
+    modelID: z2.string().min(1)
+  }),
+  kind: z2.enum(["local", "frontier", "router"]),
+  contextWindow: z2.number().int().positive(),
+  maxOutputTokens: z2.number().int().positive(),
+  supportsToolCalling: z2.boolean(),
+  supportsVision: z2.boolean(),
+  reasoningTier: CapabilityTierSchema,
+  codeQualityTier: CapabilityTierSchema,
+  costPer1M: z2.object({
+    inputUSD: z2.number().min(0),
+    outputUSD: z2.number().min(0)
+  }),
+  availability: z2.enum(["available", "degraded", "unavailable"])
+});
+
+// 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/plugin/capture.ts
+function nonNeg(value) {
+  return typeof value === "number" && value >= 0 ? Math.trunc(value) : 0;
+}
+function messageEventFrom(info, now) {
+  if (info.role !== "assistant") {
+    return;
+  }
+  if (info.time?.completed === undefined) {
+    return;
+  }
+  if (info.sessionID === undefined || info.providerID === undefined || info.modelID === undefined) {
+    return;
+  }
+  const created = info.time.created ?? info.time.completed;
+  const durationMs = Math.max(0, Math.trunc(info.time.completed - created));
+  const event = {
+    v: EVENT_SCHEMA_VERSION,
+    type: "message",
+    ts: now(),
+    sessionID: info.sessionID,
+    providerID: info.providerID,
+    modelID: info.modelID,
+    costUSD: typeof info.cost === "number" && info.cost >= 0 ? info.cost : 0,
+    tokensIn: nonNeg(info.tokens?.input),
+    tokensOut: nonNeg(info.tokens?.output),
+    tokensReasoning: nonNeg(info.tokens?.reasoning),
+    tokensCacheRead: nonNeg(info.tokens?.cache?.read),
+    tokensCacheWrite: nonNeg(info.tokens?.cache?.write),
+    durationMs
+  };
+  if (info.mode !== undefined) {
+    event.mode = info.mode;
+  }
+  if (info.id !== undefined) {
+    event.messageID = info.id;
+  }
+  return event;
+}
+var ACTIVITY_SUMMARIES = {
+  "session.created": "Sesión creada",
+  "session.idle": "Sesión en reposo",
+  "session.error": "Error de sesión"
+};
+function sessionIDFromEvent(event) {
+  const properties = event.properties;
+  if (properties === null || typeof properties !== "object") {
+    return;
+  }
+  const record = properties;
+  if (typeof record.sessionID === "string") {
+    return record.sessionID;
+  }
+  if (typeof record.info?.id === "string") {
+    return record.info.id;
+  }
+  return;
+}
+function activityEventFrom(event, now) {
+  const summary = ACTIVITY_SUMMARIES[event.type];
+  if (summary === undefined) {
+    return;
+  }
+  const sessionID = sessionIDFromEvent(event);
+  if (sessionID === undefined) {
+    return;
+  }
+  return {
+    v: EVENT_SCHEMA_VERSION,
+    type: "activity",
+    ts: now(),
+    sessionID,
+    kind: "agent",
+    summary
+  };
+}
+
 // src/plugin/commandTool.ts
 import { tool } from "@opencode-ai/plugin";
 
@@ -970,25 +1170,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(`
 `);
 }
@@ -1142,7 +1336,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)",
@@ -1814,81 +2009,67 @@ function toCostRecord(decision2, context) {
   return record;
 }
 
-// src/telemetry/hash.ts
-var FNV_OFFSET_BASIS = 2166136261;
-var FNV_PRIME = 16777619;
-function hashPrompt(prompt) {
-  let hash = FNV_OFFSET_BASIS;
-  for (let index = 0;index < prompt.length; index += 1) {
-    hash ^= prompt.charCodeAt(index);
-    hash = Math.imul(hash, FNV_PRIME);
-  }
-  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
-}
-
 // src/telemetry/types.ts
-import { z as z3 } from "zod";
-
-// src/capabilities/types.ts
-import { z as z2 } from "zod";
-var CapabilityTierSchema = z2.union([
-  z2.literal(0),
-  z2.literal(1),
-  z2.literal(2),
-  z2.literal(3),
-  z2.literal(4),
-  z2.literal(5)
-]);
-var ComplexityTierSchema = z2.enum([
-  "trivial",
-  "simple",
-  "moderate",
-  "hard"
-]);
-var ModelCapabilityProfileSchema = z2.object({
-  ref: z2.object({
-    providerID: z2.string().min(1),
-    modelID: z2.string().min(1)
-  }),
-  kind: z2.enum(["local", "frontier", "router"]),
-  contextWindow: z2.number().int().positive(),
-  maxOutputTokens: z2.number().int().positive(),
-  supportsToolCalling: z2.boolean(),
-  supportsVision: z2.boolean(),
-  reasoningTier: CapabilityTierSchema,
-  codeQualityTier: CapabilityTierSchema,
-  costPer1M: z2.object({
-    inputUSD: z2.number().min(0),
-    outputUSD: z2.number().min(0)
-  }),
-  availability: z2.enum(["available", "degraded", "unavailable"])
-});
-
-// 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),
+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: z3.enum(["local", "frontier"]),
+  routeKind: z4.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()
+  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/sink.ts
-function createJsonlSink(deps) {
+// 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 sessionFileName(sessionID) {
+  const safe = sessionID.replace(/[^A-Za-z0-9._-]/g, "_");
+  return `${safe}.jsonl`;
+}
+function defaultJoin(dir, file) {
+  return dir.endsWith("/") ? `${dir}${file}` : `${dir}/${file}`;
+}
+function createEventLogSink(deps) {
+  const join = deps.join ?? defaultJoin;
   return {
-    record: async (record) => {
+    emit: async (event) => {
       try {
-        const parsed = CostRecordSchema.parse(record);
-        await deps.append(`${JSON.stringify(parsed)}
+        const parsed = OpenTeamEventSchema.parse(event);
+        const path = join(deps.dir, sessionFileName(parsed.sessionID));
+        await deps.appendLine(path, `${JSON.stringify(parsed)}
 `);
       } catch (error) {
         deps.onError?.(error);
@@ -1896,10 +2077,117 @@ function createJsonlSink(deps) {
     }
   };
 }
-function createNullSink() {
-  return {
-    record: () => {}
+function createNullEventSink() {
+  return { emit: () => {} };
+}
+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/telemetry/hash.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+function hashPrompt(prompt) {
+  let hash = FNV_OFFSET_BASIS;
+  for (let index = 0;index < prompt.length; index += 1) {
+    hash ^= prompt.charCodeAt(index);
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
 }
 
 // src/plugin/hooks.ts
@@ -1932,8 +2220,8 @@ function promptText(output) {
   return output.parts.map(partText).join(`
 `);
 }
-function emitTelemetry(sink, record) {
-  Promise.resolve().then(() => sink.record(record)).catch(() => {});
+function emitTelemetry(sink, event) {
+  Promise.resolve().then(() => sink.emit(event)).catch(() => {});
 }
 function deriveTaskSignals(input, output) {
   const prompt = promptText(output);
@@ -1954,7 +2242,7 @@ function deriveTaskSignals(input, output) {
   return signals;
 }
 function createChatMessageHook(config, getAvailable, options = {}) {
-  const sink = options.sink ?? createNullSink();
+  const sink = options.sink ?? createNullEventSink();
   const now = options.now ?? Date.now;
   return async (input, output) => {
     const signals = deriveTaskSignals(input, output);
@@ -1976,7 +2264,7 @@ function createChatMessageHook(config, getAvailable, options = {}) {
     if (signals.estimatedOutputTokens !== undefined) {
       telemetryContext.tokensOut = signals.estimatedOutputTokens;
     }
-    emitTelemetry(sink, toCostRecord(decision2, telemetryContext));
+    emitTelemetry(sink, costRecordToRouteEvent(toCostRecord(decision2, telemetryContext)));
   };
 }
 function createHooks(config, getAvailable, options = {}) {
@@ -1985,615 +2273,34 @@ function createHooks(config, getAvailable, options = {}) {
   };
 }
 
-// src/telemetry/read.ts
-import { readFile } from "node:fs/promises";
-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/plugin/toolcalls.ts
+function key(sessionID, callID) {
+  return `${sessionID}\x00${callID}`;
 }
-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 [];
-    }
-    throw error;
-  }
-}
-
-// src/web/paths.ts
-var DEFAULT_BACKLOG_PATH = ".opencode/openteam-backlog.md";
-
-// src/web/start.ts
-import { watch as fsWatch } from "node:fs";
-
-// src/web/activity.ts
-function createActivityBuffer(max = 100) {
-  const entries = [];
+function createToolcallTracker(deps) {
+  const now = deps.now ?? Date.now;
+  const started = new Map;
   return {
-    push(entry) {
-      entries.push(entry);
-      if (entries.length > max) {
-        entries.splice(0, entries.length - max);
-      }
+    before(input) {
+      started.set(key(input.sessionID, input.callID), now());
     },
-    list() {
-      return [...entries];
-    }
-  };
-}
-
-// src/dashboard/render.ts
-var TIERS2 = [
-  "trivial",
-  "simple",
-  "moderate",
-  "hard"
-];
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function usd2(value) {
-  return `$${value.toFixed(5)}`;
-}
-function pct(value) {
-  return `${value.toFixed(2)}%`;
-}
-function agentModel(agent) {
-  return agent.model === undefined ? "hereda default" : `${agent.model.providerID}/${agent.model.modelID}`;
-}
-function summaryPanel(cost) {
-  return [
-    '<section class="panel" id="panel-summary">',
-    "<h2>Resumen de routing</h2>",
-    '<div class="grid">',
-    `<div class="stat"><span class="k">Decisiones</span><span class="v">${cost.count}</span></div>`,
-    `<div class="stat"><span class="k">Local</span><span class="v">${cost.localCount}</span></div>`,
-    `<div class="stat"><span class="k">Frontier</span><span class="v">${cost.frontierCount}</span></div>`,
-    `<div class="stat"><span class="k">Coste real</span><span class="v">${usd2(cost.totalEstimatedUSD)}</span></div>`,
-    `<div class="stat"><span class="k">Baseline</span><span class="v">${usd2(cost.totalBaselineUSD)}</span></div>`,
-    `<div class="stat"><span class="k">Ahorro</span><span class="v good">${usd2(cost.totalSavingsUSD)} (${pct(cost.savingsPct)})</span></div>`,
-    `<div class="stat"><span class="k">Tokens in</span><span class="v">${cost.tokensIn}</span></div>`,
-    `<div class="stat"><span class="k">Tokens out</span><span class="v">${cost.tokensOut}</span></div>`,
-    "</div>",
-    "</section>"
-  ].join("");
-}
-function tierPanel(cost) {
-  const rows = TIERS2.map((tier) => {
-    const summary = cost.byTier[tier];
-    return `<tr><td>${tier}</td><td>${summary.count}</td><td>${usd2(summary.estimatedUSD)}</td><td class="good">${usd2(summary.savingsUSD)}</td></tr>`;
-  }).join("");
-  return [
-    '<section class="panel" id="panel-tier">',
-    "<h2>Por tier</h2>",
-    "<table><thead><tr><th>Tier</th><th>Nº</th><th>Coste</th><th>Ahorro</th></tr></thead>",
-    `<tbody>${rows}</tbody></table>`,
-    "</section>"
-  ].join("");
-}
-function loopItemRow(item) {
-  const box = item.done ? "☑" : "☐";
-  const cls = item.done ? "done" : "open";
-  const who = item.assignee === undefined ? "" : `<span class="who">@${escapeHtml(item.assignee)}</span> `;
-  return `<li class="${cls}"><span class="box">${box}</span> ${who}${escapeHtml(item.text)}</li>`;
-}
-function loopPanel(loop) {
-  if (loop === undefined) {
-    return [
-      '<section class="panel" id="panel-loop">',
-      "<h2>Loop</h2>",
-      '<p class="muted">Sin backlog activo (no hay <code>openteam-backlog.md</code>).</p>',
-      "</section>"
-    ].join("");
-  }
-  const items = loop.items.map(loopItemRow).join("");
-  const commit = loop.lastCommit === undefined ? "" : `<p class="muted">Último commit: <code>${escapeHtml(loop.lastCommit.hash)}</code> ${escapeHtml(loop.lastCommit.subject)}</p>`;
-  return [
-    '<section class="panel" id="panel-loop">',
-    "<h2>Loop</h2>",
-    `<div class="progress" role="progressbar" aria-valuenow="${loop.progressPct}" aria-valuemin="0" aria-valuemax="100"><div class="bar" style="width:${loop.progressPct}%"></div></div>`,
-    `<p class="muted">${loop.done}/${loop.total} completados · ${loop.open} abiertos · ${loop.progressPct}%</p>`,
-    `<ul class="items">${items}</ul>`,
-    commit,
-    "</section>"
-  ].join("");
-}
-function teamPanel(team) {
-  if (team.length === 0) {
-    return [
-      '<section class="panel" id="panel-team">',
-      "<h2>Equipo</h2>",
-      '<p class="muted">Sin agentes en <code>.opencode/agent/</code>.</p>',
-      "</section>"
-    ].join("");
-  }
-  const rows = team.map((agent) => `<tr><td>${escapeHtml(agent.name)}</td><td>${escapeHtml(agent.mode)}</td><td>${escapeHtml(agentModel(agent))}</td></tr>`).join("");
-  return [
-    '<section class="panel" id="panel-team">',
-    "<h2>Equipo</h2>",
-    "<table><thead><tr><th>Agente</th><th>Modo</th><th>LLM</th></tr></thead>",
-    `<tbody>${rows}</tbody></table>`,
-    "</section>"
-  ].join("");
-}
-function routeRow(route) {
-  return `<tr><td>${route.tier}</td><td class="${route.routeKind}">${route.routeKind}</td><td>${escapeHtml(route.model)}</td><td class="hash">${escapeHtml(route.promptHash)}</td><td>${usd2(route.estimatedCostUSD)}</td><td class="good">${usd2(route.estimatedSavingsUSD)}</td></tr>`;
-}
-function routesPanel(routes) {
-  if (routes.length === 0) {
-    return [
-      '<section class="panel" id="panel-routes">',
-      "<h2>Decisiones recientes</h2>",
-      '<p class="muted">Sin decisiones de routing todavía.</p>',
-      "</section>"
-    ].join("");
-  }
-  const rows = routes.map(routeRow).join("");
-  return [
-    '<section class="panel" id="panel-routes">',
-    "<h2>Decisiones recientes</h2>",
-    "<table><thead><tr><th>Tier</th><th>Ruta</th><th>Modelo</th><th>Prompt (hash)</th><th>Coste</th><th>Ahorro</th></tr></thead>",
-    `<tbody>${rows}</tbody></table>`,
-    "</section>"
-  ].join("");
-}
-function activityRow(entry) {
-  const who = entry.agent === undefined ? "" : `<span class="who">${escapeHtml(entry.agent)}</span> `;
-  return `<li class="${entry.kind}"><span class="kind">${entry.kind}</span> ${who}${escapeHtml(entry.summary)}</li>`;
-}
-function activityPanel(activity) {
-  if (activity.length === 0) {
-    return [
-      '<section class="panel" id="panel-activity">',
-      "<h2>Actividad</h2>",
-      '<p class="muted">Sin actividad registrada.</p>',
-      "</section>"
-    ].join("");
-  }
-  const rows = activity.map(activityRow).join("");
-  return [
-    '<section class="panel" id="panel-activity">',
-    "<h2>Actividad</h2>",
-    `<ul class="timeline">${rows}</ul>`,
-    "</section>"
-  ].join("");
-}
-var STYLE = `
-:root{color-scheme:dark;--bg:#0f1115;--panel:#171a21;--fg:#e6e8eb;--muted:#8b929c;--good:#3fb950;--local:#58a6ff;--frontier:#d29922;--line:#262b34}
-*{box-sizing:border-box}
-body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.5 ui-sans-serif,system-ui,Segoe UI,Roboto,sans-serif}
-header{padding:16px 24px;border-bottom:1px solid var(--line);display:flex;justify-content:space-between;align-items:baseline;gap:12px;flex-wrap:wrap}
-header h1{font-size:18px;margin:0}
-header .meta{color:var(--muted);font-size:12px}
-main{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:16px;padding:24px}
-.panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:16px}
-.panel h2{font-size:14px;margin:0 0 12px;color:var(--muted);text-transform:uppercase;letter-spacing:.04em}
-.grid{display:grid;grid-template-columns:repeat(2,1fr);gap:10px}
-.stat{display:flex;flex-direction:column;gap:2px}
-.stat .k{color:var(--muted);font-size:12px}
-.stat .v{font-size:18px;font-weight:600}
-.good{color:var(--good)}
-.local{color:var(--local)}
-.frontier{color:var(--frontier)}
-.muted{color:var(--muted)}
-table{width:100%;border-collapse:collapse;font-size:13px}
-th,td{text-align:left;padding:6px 8px;border-bottom:1px solid var(--line)}
-th{color:var(--muted);font-weight:600}
-.hash{font-family:ui-monospace,Consolas,monospace;color:var(--muted)}
-.progress{height:10px;background:#0b0d11;border-radius:6px;overflow:hidden;border:1px solid var(--line)}
-.progress .bar{height:100%;background:var(--good)}
-ul.items,ul.timeline{list-style:none;margin:8px 0 0;padding:0;max-height:320px;overflow:auto}
-ul.items li,ul.timeline li{padding:4px 0;border-bottom:1px solid var(--line)}
-ul.items li.done{color:var(--muted)}
-ul.items .box{font-family:monospace}
-.who{color:var(--local)}
-.kind{display:inline-block;min-width:66px;color:var(--muted);font-size:12px}
-code{font-family:ui-monospace,Consolas,monospace;background:#0b0d11;padding:1px 5px;border-radius:4px}
-`;
-var CLIENT_JS = `
-(function(){
-  function reloadIfChanged(prev){
-    fetch('/api/state').then(function(r){return r.json()}).then(function(s){
-      if(s.generatedAt!==prev){location.reload()}
-    }).catch(function(){});
-  }
-  var current=document.documentElement.getAttribute('data-generated')||'';
-  if('EventSource' in window){
-    try{
-      var es=new EventSource('/events');
-      es.addEventListener('state',function(){location.reload()});
-      es.onerror=function(){/* fallback below */};
-    }catch(e){/* ignore */}
-  }
-  var ms=parseInt(document.documentElement.getAttribute('data-refresh')||'2000',10);
-  setInterval(function(){reloadIfChanged(current)},isNaN(ms)?2000:Math.max(250,ms));
-})();
-`;
-function renderDashboardHtml(state, options = {}) {
-  const refreshMs = options.refreshMs ?? 2000;
-  const body = [
-    summaryPanel(state.cost),
-    loopPanel(state.loop),
-    teamPanel(state.team),
-    tierPanel(state.cost),
-    routesPanel(state.recentRoutes),
-    activityPanel(state.activity)
-  ].join("");
-  const session = state.session.id === undefined ? "" : ` · sesión ${escapeHtml(state.session.id)}`;
-  return [
-    "<!doctype html>",
-    `<html lang="es" data-generated="${escapeHtml(state.generatedAt)}" data-refresh="${refreshMs}">`,
-    "<head>",
-    '<meta charset="utf-8">',
-    '<meta name="viewport" content="width=device-width,initial-scale=1">',
-    "<title>openteam dashboard</title>",
-    `<style>${STYLE}</style>`,
-    "</head>",
-    "<body>",
-    "<header>",
-    "<h1>openteam dashboard</h1>",
-    `<span class="meta">actualizado ${escapeHtml(state.generatedAt)}${session}</span>`,
-    "</header>",
-    `<main>${body}</main>`,
-    `<script>${CLIENT_JS}</script>`,
-    "</body>",
-    "</html>"
-  ].join("");
-}
-
-// src/dashboard/backlog.ts
-var ITEM_RE = /^\s*[-*+]\s+\[( |x|X)\]\s+(.*)$/;
-var ASSIGNEE_RE = /^\[@([^\]]+)\]\s*(.*)$/;
-function parseAssignee(text) {
-  const match = ASSIGNEE_RE.exec(text);
-  if (match === null) {
-    return { text: text.trim() };
-  }
-  const assignee = (match[1] ?? "").trim();
-  const rest = (match[2] ?? "").trim();
-  if (assignee.length === 0) {
-    return { text: text.trim() };
-  }
-  return { assignee, text: rest };
-}
-function parseBacklog(text) {
-  const items = [];
-  for (const line of text.split(/\r?\n/)) {
-    const match = ITEM_RE.exec(line);
-    if (match === null) {
-      continue;
-    }
-    const done = (match[1] ?? " ").toLowerCase() === "x";
-    const rawText = (match[2] ?? "").trim();
-    const { assignee, text: itemText } = parseAssignee(rawText);
-    const item = { text: itemText, done };
-    if (assignee !== undefined) {
-      item.assignee = assignee;
-    }
-    items.push(item);
-  }
-  return items;
-}
-function buildLoopSnapshot(backlogPath, items) {
-  const total = items.length;
-  const done = items.filter((item) => item.done).length;
-  const open = total - done;
-  const progressPct = total === 0 ? 100 : Math.round(done / total * 100);
-  return {
-    backlogPath,
-    total,
-    done,
-    open,
-    progressPct,
-    items: [...items]
-  };
-}
-
-// src/dashboard/state.ts
-var DEFAULT_RECENT_ROUTES = 50;
-var DEFAULT_ACTIVITY_LIMIT = 100;
-function toRouteView(record) {
-  return {
-    ts: record.ts,
-    tier: record.tier,
-    routeKind: record.routeKind,
-    model: `${record.selected.providerID}/${record.selected.modelID}`,
-    promptHash: record.promptHash,
-    estimatedCostUSD: record.estimatedCostUSD,
-    estimatedSavingsUSD: record.estimatedSavingsUSD,
-    budgetAction: record.budgetAction
-  };
-}
-function recentRoutes(records, limit) {
-  return [...records].sort((a, b) => b.ts - a.ts).slice(0, Math.max(0, limit)).map(toRouteView);
-}
-function recentActivity(entries, limit) {
-  return [...entries].sort((a, b) => b.ts - a.ts).slice(0, Math.max(0, limit));
-}
-function loopFrom(backlog) {
-  if (backlog === undefined) {
-    return;
-  }
-  const snapshot = buildLoopSnapshot(backlog.path, backlog.items);
-  if (backlog.lastCommit !== undefined) {
-    snapshot.lastCommit = backlog.lastCommit;
-  }
-  return snapshot;
-}
-function buildDashboardState(inputs) {
-  const recentRoutesLimit = inputs.recentRoutesLimit ?? DEFAULT_RECENT_ROUTES;
-  const activityLimit = inputs.activityLimit ?? DEFAULT_ACTIVITY_LIMIT;
-  const state = {
-    generatedAt: inputs.generatedAt,
-    session: {},
-    cost: summarizeCostRecords(inputs.costRecords),
-    recentRoutes: recentRoutes(inputs.costRecords, recentRoutesLimit),
-    team: [...inputs.team],
-    activity: recentActivity(inputs.activity, activityLimit)
-  };
-  if (inputs.session?.id !== undefined) {
-    state.session.id = inputs.session.id;
-  }
-  if (inputs.session?.startedAt !== undefined) {
-    state.session.startedAt = inputs.session.startedAt;
-  }
-  const loop = loopFrom(inputs.backlog);
-  if (loop !== undefined) {
-    state.loop = loop;
-  }
-  return state;
-}
-
-// src/web/server.ts
-var SSE_HEADERS = {
-  "content-type": "text/event-stream",
-  "cache-control": "no-cache",
-  connection: "keep-alive"
-};
-var JSON_HEADERS = { "content-type": "application/json" };
-var HTML_HEADERS = { "content-type": "text/html; charset=utf-8" };
-function isAddressInUse(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE";
-}
-async function renderState(deps) {
-  return renderDashboardHtml(buildDashboardState(await deps.readSnapshot()), {
-    refreshMs: deps.config.refreshMs
-  });
-}
-async function stateJson(deps) {
-  return JSON.stringify(buildDashboardState(await deps.readSnapshot()));
-}
-function sseMessage(json) {
-  return `event: state
-data: ${json}
-
-`;
-}
-function createDashboardServer(deps) {
-  const serve = deps.serve ?? Bun.serve;
-  const log = deps.log ?? ((message) => console.log(message));
-  const encoder = new TextEncoder;
-  const clients = new Set;
-  const handler = async (request) => {
-    const url2 = new URL(request.url);
-    if (request.method !== "GET") {
-      return new Response("method not allowed", { status: 405 });
-    }
-    if (url2.pathname === "/" || url2.pathname === "/index.html") {
-      return new Response(await renderState(deps), { headers: HTML_HEADERS });
-    }
-    if (url2.pathname === "/api/state") {
-      return new Response(await stateJson(deps), { headers: JSON_HEADERS });
-    }
-    if (url2.pathname === "/healthz") {
-      return new Response(JSON.stringify({ ok: true }), {
-        headers: JSON_HEADERS
-      });
-    }
-    if (url2.pathname === "/favicon.ico") {
-      return new Response(null, { status: 204 });
-    }
-    if (url2.pathname === "/events") {
-      const initial = await stateJson(deps);
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.enqueue(encoder.encode(sseMessage(initial)));
-          clients.add(controller);
-        },
-        cancel(controller) {
-          clients.delete(controller);
-        }
-      });
-      return new Response(stream, { headers: SSE_HEADERS });
-    }
-    return new Response("not found", { status: 404 });
-  };
-  const maxAttempts = deps.config.autoPortFallback ? 20 : 1;
-  let server;
-  let lastError;
-  for (let offset = 0;offset < maxAttempts; offset += 1) {
-    const port = deps.config.port + offset;
-    if (port > 65535) {
-      break;
-    }
-    try {
-      server = serve({
-        hostname: deps.config.host,
-        port,
-        fetch: handler
-      });
-      break;
-    } catch (error) {
-      lastError = error;
-      if (!isAddressInUse(error)) {
-        throw error;
-      }
-    }
-  }
-  if (server === undefined) {
-    throw lastError ?? new Error("dashboard: no available port");
-  }
-  const boundPort = server.port ?? deps.config.port;
-  const url = `http://${deps.config.host}:${boundPort}`;
-  log(`[openteam] dashboard en ${url}`);
-  const notify = async () => {
-    if (clients.size === 0) {
-      return;
-    }
-    const message = encoder.encode(sseMessage(await stateJson(deps)));
-    for (const controller of clients) {
-      try {
-        controller.enqueue(message);
-      } catch {
-        clients.delete(controller);
-      }
-    }
-  };
-  const close = () => {
-    for (const controller of clients) {
-      try {
-        controller.close();
-      } catch {}
-    }
-    clients.clear();
-    server.stop(true);
-  };
-  return { url, port: boundPort, notify, close };
-}
-
-// src/web/snapshot.ts
-function createSnapshotReader(deps, paths, context) {
-  return async () => {
-    const [telemetryText, backlogText, agentFiles, lastCommit] = await Promise.all([
-      deps.readText(paths.telemetryPath),
-      deps.readText(paths.backlogPath),
-      deps.listAgentFiles(paths.agentDir),
-      deps.gitLastCommit?.() ?? Promise.resolve(undefined)
-    ]);
-    const costRecords = parseCostRecordsJsonl(telemetryText ?? "");
-    const team = agentFiles.map(parseAgentFile);
-    const inputs = {
-      generatedAt: deps.now(),
-      costRecords,
-      team,
-      activity: context.activity()
-    };
-    if (backlogText !== undefined) {
-      const backlog = {
-        path: paths.backlogPath,
-        items: parseBacklog(backlogText)
+    after(input) {
+      const mapKey = key(input.sessionID, input.callID);
+      const start = started.get(mapKey);
+      started.delete(mapKey);
+      const end = now();
+      const durationMs = start === undefined ? 0 : Math.max(0, end - start);
+      const event = {
+        v: EVENT_SCHEMA_VERSION,
+        type: "toolcall",
+        ts: end,
+        sessionID: input.sessionID,
+        tool: input.tool,
+        callID: input.callID,
+        durationMs,
+        ok: true
       };
-      if (lastCommit !== undefined) {
-        backlog.lastCommit = lastCommit;
-      }
-      inputs.backlog = backlog;
-    }
-    if (context.session !== undefined) {
-      inputs.session = context.session;
-    }
-    if (context.recentRoutesLimit !== undefined) {
-      inputs.recentRoutesLimit = context.recentRoutesLimit;
-    }
-    return inputs;
-  };
-}
-
-// src/web/watch.ts
-function watchSources(paths, onChange, deps, debounceMs = 250) {
-  const setTimer = deps.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
-  const clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
-  const watchers = [];
-  let pending;
-  const trigger = () => {
-    if (pending !== undefined) {
-      clearTimer(pending);
-    }
-    pending = setTimer(() => {
-      pending = undefined;
-      onChange();
-    }, debounceMs);
-  };
-  for (const path of paths) {
-    try {
-      watchers.push(deps.watch(path, trigger));
-    } catch {}
-  }
-  return {
-    close() {
-      if (pending !== undefined) {
-        clearTimer(pending);
-        pending = undefined;
-      }
-      for (const watcher of watchers) {
-        watcher.close();
-      }
-    }
-  };
-}
-
-// src/web/start.ts
-function startDashboard(deps) {
-  const backlogPath = deps.backlogPath ?? DEFAULT_BACKLOG_PATH;
-  const activity = createActivityBuffer(deps.config.recentRoutes);
-  const readSnapshot = createSnapshotReader({
-    readText: deps.readText,
-    listAgentFiles: deps.listAgentFiles,
-    now: deps.now,
-    ...deps.gitLastCommit !== undefined ? { gitLastCommit: deps.gitLastCommit } : {}
-  }, {
-    telemetryPath: deps.telemetryPath,
-    backlogPath,
-    agentDir: deps.agentDir
-  }, {
-    activity: () => activity.list(),
-    recentRoutesLimit: deps.config.recentRoutes,
-    ...deps.session !== undefined ? { session: deps.session } : {}
-  });
-  const createServer = deps.serve ?? createDashboardServer;
-  const server = createServer({
-    readSnapshot,
-    config: deps.config,
-    ...deps.log !== undefined ? { log: deps.log } : {}
-  });
-  const watchFn = deps.watch ?? ((path, listener) => fsWatch(path, { persistent: false }, listener));
-  const watcher = watchSources([deps.telemetryPath, backlogPath, deps.agentDir], () => {
-    server.notify();
-  }, { watch: watchFn });
-  return {
-    url: server.url,
-    port: server.port,
-    pushActivity(entry) {
-      activity.push(entry);
-      server.notify();
-    },
-    close() {
-      watcher.close();
-      server.close();
+      return deps.sink.emit(event);
     }
   };
 }
@@ -2621,9 +2328,11 @@ function telemetryOptions(rawOptions) {
   const telemetry = rawOptions !== null && typeof rawOptions === "object" && "telemetry" in rawOptions && rawOptions.telemetry !== null && typeof rawOptions.telemetry === "object" ? rawOptions.telemetry : {};
   const enabled = !("enabled" in telemetry) || telemetry.enabled !== false;
   const configuredPath = "path" in telemetry && typeof telemetry.path === "string" ? telemetry.path : DEFAULT_TELEMETRY_PATH;
+  const configuredSessionsDir = "sessionsDir" in telemetry && typeof telemetry.sessionsDir === "string" ? telemetry.sessionsDir : DEFAULT_SESSIONS_DIR;
   return {
     enabled,
-    path: configuredPath
+    path: configuredPath,
+    sessionsDir: configuredSessionsDir
   };
 }
 function createFileAppender(filePath, deps = {}) {
@@ -2634,65 +2343,36 @@ function createFileAppender(filePath, deps = {}) {
     await appendFileFn(filePath, line, "utf8");
   };
 }
-function createTelemetrySink(rawOptions) {
+function createPathAppender(deps = {}) {
+  const mkdirFn = deps.mkdir ?? mkdir2;
+  const appendFileFn = deps.appendFile ?? appendFile;
+  return async (path, line) => {
+    await mkdirFn(dirname2(path), { recursive: true });
+    await appendFileFn(path, line, "utf8");
+  };
+}
+function createEventSink(rawOptions) {
   const options = telemetryOptions(rawOptions);
   if (!options.enabled) {
-    return createNullSink();
+    return createNullEventSink();
   }
-  return createJsonlSink({
-    append: createFileAppender(options.path),
+  return createEventLogSink({
+    dir: options.sessionsDir,
+    appendLine: createPathAppender(),
+    join,
     onError: logTelemetryError
   });
 }
-function isMissingFile2(error) {
+function isMissingFile(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-async function readTextOptional(path) {
-  try {
-    return await readFile2(path, "utf8");
-  } catch (error) {
-    if (isMissingFile2(error)) {
-      return;
-    }
-    throw error;
-  }
-}
-function createGitLastCommit(exec) {
-  return async () => {
-    const output = await exec("git", [
-      "log",
-      "-1",
-      "--pretty=format:%h%x1f%s%x1f%cI"
-    ]);
-    if (output.exitCode !== 0) {
-      return;
-    }
-    const [hash, subject, at] = output.stdout.trim().split("\x1F");
-    if (hash === undefined || subject === undefined || at === undefined) {
-      return;
-    }
-    return { hash, subject, at };
-  };
-}
-var DASHBOARD_EVENT_SUMMARIES = {
-  "session.created": "Sesión creada",
-  "session.idle": "Sesión en reposo",
-  "session.error": "Error de sesión"
-};
-function activityFromEvent(event, now) {
-  const summary = DASHBOARD_EVENT_SUMMARIES[event.type];
-  if (summary === undefined) {
-    return;
-  }
-  return { ts: now(), kind: "agent", summary };
-}
-function createCliDeps(config, registry, telemetryPath) {
+function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SESSIONS_DIR) {
   return {
     loadConfig: async (path) => {
       try {
-        return loadOpenTeamConfig(JSON.parse(await readFile2(path, "utf8")));
+        return loadOpenTeamConfig(JSON.parse(await readFile(path, "utf8")));
       } catch (error) {
-        if (isMissingFile2(error)) {
+        if (isMissingFile(error)) {
           return config;
         }
         throw error;
@@ -2701,9 +2381,9 @@ function createCliDeps(config, registry, telemetryPath) {
     saveConfig: (nextConfig, path) => writeOpenTeamConfigFile(nextConfig, path),
     readOpencodeConfig: async (path) => {
       try {
-        return JSON.parse(await readFile2(path, "utf8"));
+        return JSON.parse(await readFile(path, "utf8"));
       } catch (error) {
-        if (isMissingFile2(error)) {
+        if (isMissingFile(error)) {
           return;
         }
         throw error;
@@ -2723,7 +2403,7 @@ function createCliDeps(config, registry, telemetryPath) {
       try {
         entries = await readdir(dir);
       } catch (error) {
-        if (isMissingFile2(error)) {
+        if (isMissingFile(error)) {
           return [];
         }
         throw error;
@@ -2731,11 +2411,33 @@ function createCliDeps(config, registry, telemetryPath) {
       const mdFiles = entries.filter((entry) => entry.endsWith(".md"));
       return Promise.all(mdFiles.map(async (entry) => ({
         name: entry.replace(/\.md$/, ""),
-        contents: await readFile2(join(dir, entry), "utf8")
+        contents: await readFile(join(dir, entry), "utf8")
       })));
     },
     probe: (nextConfig) => registry.probe(nextConfig.local.runtimes),
-    readTelemetry: (path) => readCostRecords(path),
+    readTelemetry: (path) => readRouteCostRecords(sessionsDir, {
+      listFiles: async (dir) => {
+        try {
+          return await readdir(dir);
+        } catch (error) {
+          if (isMissingFile(error)) {
+            return [];
+          }
+          throw error;
+        }
+      },
+      readText: async (filePath) => {
+        try {
+          return await readFile(filePath, "utf8");
+        } catch (error) {
+          if (isMissingFile(error)) {
+            return;
+          }
+          throw error;
+        }
+      },
+      legacyTelemetryPath: path
+    }),
     configPath: DEFAULT_CONFIG_PATH,
     telemetryPath,
     opencodeConfigPath: OPENCODE_CONFIG_PATH,
@@ -2757,43 +2459,36 @@ var server = async (ctx, rawOptions) => {
   });
   cache.refresh();
   const telemetryPath = telemetryOptions(rawOptions).path;
-  const hooks = createHooks(config, cache.get, {
-    sink: createTelemetrySink(rawOptions)
-  });
-  const cliDeps = createCliDeps(config, registry, telemetryPath);
-  let dashboard;
-  if (config.dashboard.enabled) {
-    try {
-      dashboard = startDashboard({
-        config: config.dashboard,
-        telemetryPath,
-        agentDir: dirname2(ORCHESTRATOR_AGENT_PATH),
-        backlogPath: DEFAULT_BACKLOG_PATH,
-        readText: readTextOptional,
-        listAgentFiles: cliDeps.listAgentFiles,
-        now: () => new Date().toISOString(),
-        gitLastCommit: createGitLastCommit(createShellExec(ctx.$)),
-        log: (message) => console.log(`[openteam] ${message}`)
-      });
-      console.log(`[openteam] dashboard en ${dashboard.url}`);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(`[openteam] no se pudo iniciar el dashboard: ${message}`);
-    }
-  }
+  const sessionsDir = telemetryOptions(rawOptions).sessionsDir;
+  const sink = createEventSink(rawOptions);
+  const hooks = createHooks(config, cache.get, { sink });
+  const cliDeps = createCliDeps(config, registry, telemetryPath, sessionsDir);
+  const toolcalls = createToolcallTracker({ sink });
+  const now = () => Date.now();
   return {
     ...hooks,
     tool: {
       openteam: createCommandTool(cliDeps)
     },
+    "tool.execute.before": async (input) => {
+      toolcalls.before(input);
+    },
+    "tool.execute.after": async (input) => {
+      await toolcalls.after(input);
+    },
     event: async ({ event }) => {
       if (event.type === "session.created" || event.type === "session.idle") {
         cache.refresh();
       }
-      if (dashboard !== undefined) {
-        const entry = activityFromEvent(event, () => Date.now());
-        if (entry !== undefined) {
-          dashboard.pushActivity(entry);
+      const activity = activityEventFrom(event, now);
+      if (activity !== undefined) {
+        sink.emit(activity);
+      }
+      if (event.type === "message.updated") {
+        const info = event.properties?.info;
+        const message = info === undefined ? undefined : messageEventFrom(info, now);
+        if (message !== undefined) {
+          sink.emit(message);
         }
       }
     }
@@ -2808,9 +2503,10 @@ export {
   server,
   logTelemetryError,
   logAvailabilityRefreshError,
-  isMissingFile2 as isMissingFile,
+  isMissingFile,
   src_default as default,
+  createPathAppender,
   createFileAppender,
-  createCliDeps,
-  activityFromEvent
+  createEventSink,
+  createCliDeps
 };