@xpufx/paseo-top 0.4.0

package/server/resources.ts

@@ -0,0 +1,784 @@
+import fs from "node:fs";
+import path from "node:path";
+import child_process from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(child_process.execFile);
+import os from "node:os";
+import {
+  getSystemMetrics,
+  createPluginLogger,
+  PluginStorage,
+  isPluginInstalled,
+  isPluginRunning,
+  CustomPillPoller,
+  discoverCustomPillConfigs,
+} from "paseo-plugin-helper/server";
+import {
+  type SystemResources,
+  topSettingsContract,
+  type TopSettings,
+  type ResourceField,
+  type McpResourceStatus,
+  type McpStatusSnapshot,
+  type CustomPillState,
+  type CustomPillDefinition,
+  type TopTimelineTelemetryData,
+  type LiveUsage,
+  customPillEffectiveEnabled,
+} from "../shared/resources";
+import { PLUGIN_VERSION } from "../shared/version";
+
+export const log = createPluginLogger("top", { version: PLUGIN_VERSION });
+
+log.info("Initialized host system resources monitor", { version: PLUGIN_VERSION });
+
+const CUSTOM_PILLS_DIR = path.join(os.homedir(), ".paseo", "top", "pills");
+
+try {
+  if (!fs.existsSync(CUSTOM_PILLS_DIR)) {
+    fs.mkdirSync(CUSTOM_PILLS_DIR, { recursive: true });
+    log.info("Created custom pills directory", { path: CUSTOM_PILLS_DIR });
+  }
+
+  const existingFiles = fs.readdirSync(CUSTOM_PILLS_DIR);
+  if (existingFiles.length === 0) {
+    const seedTemplates: Record<string, string> = {
+      "disk-usage.jsonc.example": `// Free disk space on root partition
+// Rename to disk-usage.jsonc to enable
+{
+  "id": "root-disk",
+  "title": "Disk",
+  "compactTitle": "Disk",
+  "icon": "HardDrive",
+  "command": "df -h / | awk 'NR==2 {print $4}'",
+  "suffix": " free",
+  "intervalMs": 10000,
+  "timeoutMs": 3000,
+  "modal": {
+    "title": "Filesystem Disk Space",
+    "description": "Output of df -h across mounted filesystems",
+    "command": "df -h",
+    "preformatted": true
+  }
+}
+`,
+      "docker-containers.jsonc.example": `// Count of running Docker containers
+// Rename to docker-containers.jsonc to enable
+{
+  "id": "docker-containers",
+  "title": "Docker",
+  "compactTitle": "Docker",
+  "icon": "Box",
+  "command": "docker ps -q 2>/dev/null | wc -l",
+  "suffix": " running",
+  "intervalMs": 5000,
+  "timeoutMs": 3000,
+  "thresholds": {
+    "warning": 10,
+    "danger": 20
+  },
+  "modal": {
+    "title": "Running Docker Containers",
+    "description": "Live container status via docker ps",
+    "command": "docker ps --format 'table {{.Names}}\\t{{.Status}}\\t{{.Ports}}'",
+    "preformatted": true
+  }
+}
+`,
+      "gpu-nvidia.jsonc.example": `// NVIDIA GPU Utilization
+// Rename to gpu-nvidia.jsonc to enable
+{
+  "id": "gpu-util",
+  "title": "GPU",
+  "compactTitle": "GPU",
+  "icon": "Cpu",
+  "command": "nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits",
+  "suffix": "%",
+  "intervalMs": 3000,
+  "timeoutMs": 2000,
+  "thresholds": {
+    "warning": 70,
+    "danger": 90
+  },
+  "modal": {
+    "title": "GPU Vitals & Memory",
+    "description": "Live hardware telemetry from nvidia-smi",
+    "command": "nvidia-smi",
+    "preformatted": true
+  }
+}
+`,
+    };
+
+    for (const [filename, content] of Object.entries(seedTemplates)) {
+      fs.writeFileSync(path.join(CUSTOM_PILLS_DIR, filename), content, "utf8");
+    }
+    log.info("Seeded sample custom pill templates", { count: Object.keys(seedTemplates).length });
+  }
+} catch (err) {
+  log.warn("Failed to ensure custom pills directory", {
+    error: err instanceof Error ? err.message : String(err),
+  });
+}
+
+export const customPillPoller = new CustomPillPoller({
+  configDir: CUSTOM_PILLS_DIR,
+  logger: log,
+});
+
+const effectiveEnabled = new Set<string>();
+
+export async function refreshCustomPillConfigs(): Promise<void> {
+  try {
+    const settings = await settingsStorage.readAsync();
+    const overrides = settings.customPillEnabled ?? {};
+    const discovered = await discoverCustomPillConfigs(CUSTOM_PILLS_DIR, log);
+    const masterEnabled = settings.showCustomPills ?? true;
+    const effective = discovered.map((pill) => {
+      const enabled = customPillEffectiveEnabled(masterEnabled, overrides, pill);
+      return enabled === pill.enabled ? pill : { ...pill, enabled };
+    });
+    effectiveEnabled.clear();
+    for (const pill of effective) {
+      if (pill.enabled) effectiveEnabled.add(pill.id);
+    }
+    customPillPoller.updatePills(effective);
+  } catch {
+    // Directory might be temporarily inaccessible
+  }
+}
+
+export async function handleGetCustomPills(): Promise<{ pills: CustomPillState[] }> {
+  await refreshCustomPillConfigs();
+  return {
+    pills: customPillPoller
+      .getAllStates()
+      .filter((state) => effectiveEnabled.has(state.id)),
+  };
+}
+
+export async function handleListCustomPills(): Promise<{ pills: CustomPillDefinition[] }> {
+  const discovered = await discoverCustomPillConfigs(CUSTOM_PILLS_DIR, log);
+  const settings = await settingsStorage.readAsync();
+  const overrides = settings.customPillEnabled ?? {};
+  const masterEnabled = settings.showCustomPills ?? true;
+  return {
+    pills: discovered.map((pill) => {
+      const override = overrides[pill.id];
+      const enabled = masterEnabled && (override === undefined ? pill.enabled : override);
+      return enabled === pill.enabled ? pill : { ...pill, enabled };
+    }),
+  };
+}
+
+export async function handleRunCustomPillModalCommand(input: {
+  pillId: string;
+}): Promise<{ output?: string; error?: string }> {
+  return customPillPoller.runModalCommand(input.pillId);
+}
+
+const settingsStorage = new PluginStorage<TopSettings>("top", "settings.json", {
+  schema: topSettingsContract.schema,
+});
+
+const mcpStorage = new PluginStorage<McpStatusSnapshot>("mcp-tools", "status.json");
+
+interface McpPluginState {
+  running: boolean;
+  installed: boolean;
+}
+
+// Resolving plugin state shells out to the paseo CLI (a full node startup,
+// ~120MB). Uncached per-RPC lookups stampede under client polling and
+// fork-bomb the host, so share one in-flight lookup with a long TTL.
+const MCP_STATE_TTL_MS = 30_000;
+let mcpStateCache: { at: number; state: McpPluginState } | null = null;
+let mcpStateInflight: Promise<McpPluginState> | null = null;
+
+export async function getMcpPluginState(): Promise<McpPluginState> {
+  const now = Date.now();
+  if (mcpStateCache && now - mcpStateCache.at < MCP_STATE_TTL_MS) {
+    return mcpStateCache.state;
+  }
+  if (!mcpStateInflight) {
+    mcpStateInflight = (async (): Promise<McpPluginState> => {
+      const running = await isPluginRunning("mcp-tools");
+      const installed = await isPluginInstalled("mcp-tools");
+      const state = { running, installed };
+      mcpStateCache = { at: Date.now(), state };
+      return state;
+    })().finally(() => {
+      mcpStateInflight = null;
+    });
+  }
+  return mcpStateInflight;
+}
+
+const SETTINGS_READ_LOG_INTERVAL_MS = 30_000;
+let lastSettingsReadLogAt = 0;
+
+export async function handleGetSettings(): Promise<TopSettings> {
+  const data = await settingsStorage.readAsync();
+  // Reads arrive on every client mount/focus verification, so keep the
+  // observable signal but bound it: at most one line per interval, keys only
+  // on writes, never full payloads.
+  const now = Date.now();
+  if (now - lastSettingsReadLogAt > SETTINGS_READ_LOG_INTERVAL_MS) {
+    lastSettingsReadLogAt = now;
+    log.debug("Settings read requested");
+  }
+  return data;
+}
+
+export async function handleUpdateSettings(patch: Partial<TopSettings>): Promise<TopSettings> {
+  log.info("Settings update requested", { keys: Object.keys(patch) });
+  const updated = await settingsStorage.updateAsync((prev) => ({ ...prev, ...patch }));
+  log.info("Settings updated successfully");
+  if (patch.customPillEnabled !== undefined || patch.showCustomPills !== undefined) {
+    await refreshCustomPillConfigs();
+  }
+  return updated;
+}
+
+export async function handleResetSettings(): Promise<TopSettings> {
+  log.info("Settings reset requested");
+  settingsStorage.reset();
+  return topSettingsContract.defaultSettings;
+}
+
+export async function resolveGitBranch(dir?: string | null): Promise<string | null> {
+  if (!dir || typeof dir !== "string") return null;
+  try {
+    const gitPath = path.join(dir, ".git");
+    try {
+      await fs.promises.access(gitPath);
+    } catch {
+      return null;
+    }
+
+    let headFile: string | null = null;
+    const stat = await fs.promises.stat(gitPath);
+    if (stat.isDirectory()) {
+      headFile = path.join(gitPath, "HEAD");
+    } else if (stat.isFile()) {
+      // Worktree pointer file: "gitdir: <path>"
+      const content = (await fs.promises.readFile(gitPath, "utf8")).trim();
+      const match = content.match(/^gitdir:\s*(.+)$/m);
+      if (match && match[1]) {
+        const gitDir = path.resolve(dir, match[1]);
+        headFile = path.join(gitDir, "HEAD");
+      }
+    }
+
+    if (headFile) {
+      let headContent: string;
+      try {
+        headContent = (await fs.promises.readFile(headFile, "utf8")).trim();
+      } catch {
+        headContent = "";
+      }
+      if (!headContent) {
+        // fall through to git command
+      } else {
+      const branchMatch = headContent.match(/^ref:\s*refs\/heads\/(.+)$/);
+      if (branchMatch && branchMatch[1]) {
+        return branchMatch[1];
+      }
+      if (/^[0-9a-f]{7,40}$/i.test(headContent)) {
+        return headContent.slice(0, 7);
+      }
+      }
+    }
+  } catch {
+    // Ignore and fall through to git command
+  }
+
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: dir,
+      timeout: 1500,
+    });
+    const branch = String(stdout).trim();
+    return branch && branch !== "HEAD" ? branch : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function handleGetSystemResources(input?: {
+  directory?: string;
+  fields?: ResourceField[];
+}): Promise<SystemResources> {
+  const fields = input?.fields;
+  const isSelective = Array.isArray(fields) && fields.length > 0;
+
+  const needCpu = !isSelective || fields.includes("cpu");
+  const needMem = !isSelective || fields.includes("memory");
+  const needLoad = !isSelective || fields.includes("load");
+  const needUptime = !isSelective || fields.includes("uptime");
+  const needBranch = !isSelective || fields.includes("branch");
+  const needMcp = !isSelective || fields.includes("mcp");
+
+  const mcpState = needMcp ? await getMcpPluginState() : undefined;
+  const mcpRunning = mcpState?.running;
+  const mcpInstalled = mcpState?.installed;
+
+  let branch: string | null | undefined = undefined;
+  if (needBranch) {
+    branch = await resolveGitBranch(input?.directory);
+  }
+
+  let cpuUsagePercent: number | undefined = undefined;
+  let usedMem: number | undefined = undefined;
+  let totalMem: number | undefined = undefined;
+  let memoryUsedPercent: number | undefined = undefined;
+  let loadAvg: number[] | undefined = undefined;
+  let uptimeSeconds: number | undefined = undefined;
+
+  let hostname: string | undefined = undefined;
+  let platform: string | undefined = undefined;
+  let arch: string | undefined = undefined;
+  let cpuModel: string | undefined = undefined;
+  let cpuCores: number | undefined = undefined;
+
+  if (needCpu || !isSelective) {
+    const metrics = getSystemMetrics();
+    cpuUsagePercent = metrics.cpu.usagePercent;
+    if (!isSelective) {
+      hostname = metrics.hostname;
+      platform = `${os.type()} ${os.release()}`;
+      arch = metrics.arch;
+      cpuModel = metrics.cpu.model;
+      cpuCores = metrics.cpu.cores;
+      loadAvg = metrics.cpu.loadAverage;
+      uptimeSeconds = metrics.uptimeSeconds;
+      totalMem = metrics.memory.totalBytes;
+      usedMem = metrics.memory.usedBytes;
+      memoryUsedPercent = Math.round(metrics.memory.usedPercent);
+    }
+  }
+
+  if (needMem) {
+    if (totalMem === undefined) {
+      totalMem = os.totalmem();
+      const freeMem = os.freemem();
+      usedMem = totalMem - freeMem;
+      memoryUsedPercent = Math.round((usedMem / totalMem) * 100);
+    }
+
+    if (process.platform === "linux") {
+      try {
+        const meminfo = await fs.promises.readFile("/proc/meminfo", "utf8");
+        const match = meminfo.match(/MemAvailable:\s+(\d+)\s+kB/);
+        if (match && match[1]) {
+          const available = parseInt(match[1], 10) * 1024;
+          usedMem = Math.max(0, totalMem - available);
+          memoryUsedPercent = Math.round((usedMem / totalMem) * 100);
+        }
+      } catch {
+        // Fallback to metrics.memory
+      }
+    }
+  }
+
+  if (needLoad && loadAvg === undefined) {
+    loadAvg = os.loadavg();
+  }
+
+  if (needUptime && uptimeSeconds === undefined) {
+    uptimeSeconds = Math.floor(os.uptime());
+  }
+
+  let mcp: McpResourceStatus | null = null;
+  if (needMcp && mcpRunning && mcpStorage.exists()) {
+    try {
+      const snapshot = await mcpStorage.readAsync();
+      if (snapshot && typeof snapshot.updatedAt === "string" && Array.isArray(snapshot.servers)) {
+        const isStale = Date.now() - new Date(snapshot.updatedAt).getTime() > 60_000;
+        mcp = {
+          updatedAt: snapshot.updatedAt,
+          total: typeof snapshot.total === "number" ? snapshot.total : snapshot.servers.length,
+          healthy: typeof snapshot.healthy === "number" ? snapshot.healthy : 0,
+          degraded: typeof snapshot.degraded === "number" ? snapshot.degraded : 0,
+          down: typeof snapshot.down === "number" ? snapshot.down : 0,
+          isStale,
+          servers: snapshot.servers,
+        };
+      }
+    } catch {
+      mcp = null;
+    }
+  }
+
+  if (!mcpRunning) {
+    mcp = null;
+  }
+
+  return {
+    version: PLUGIN_VERSION,
+    hostname,
+    platform,
+    arch,
+    cpuModel,
+    cpuCores,
+    cpuUsagePercent,
+    memoryUsedBytes: usedMem,
+    memoryTotalBytes: totalMem,
+    memoryUsedPercent,
+    loadAvg,
+    uptimeSeconds,
+    branch,
+    mcp,
+    mcpInstalled,
+    mcpRunning,
+    customPills: customPillPoller
+      .getAllStates()
+      .filter((state) => effectiveEnabled.has(state.id)),
+    lastTurn: lastTurnTelemetry,
+    liveUsage: lastLiveUsage,
+  };
+}
+
+export interface GitDiffStat {
+  insertions: number;
+  deletions: number;
+  filesChanged: number;
+}
+
+export function parseGitDiffShortstat(output: string): GitDiffStat | null {
+  const match = output.match(/(\d+)\s+files? changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/);
+  if (!match) return null;
+  return {
+    filesChanged: parseInt(match[1], 10),
+    insertions: match[2] ? parseInt(match[2], 10) : 0,
+    deletions: match[3] ? parseInt(match[3], 10) : 0,
+  };
+}
+
+export async function collectGitDiffStat(cwd: string): Promise<GitDiffStat | null> {
+  try {
+    const { stdout } = await execFileAsync("git", ["diff", "--shortstat"], {
+      cwd,
+      timeout: 2000,
+    });
+    const trimmed = String(stdout).trim();
+    if (!trimmed) return { insertions: 0, deletions: 0, filesChanged: 0 };
+    return parseGitDiffShortstat(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+export interface TurnUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  cachedTokens?: number;
+  cachedInputTokens?: number;
+  contextUsedTokens?: number;
+  contextMaxTokens?: number;
+  costUsd?: number;
+}
+
+export interface TurnActivity {
+  toolCalls: number;
+  toolErrors: number;
+  usage?: TurnUsage;
+}
+
+function readUsageRecord(record: unknown): TurnUsage | undefined {
+  if (!record || typeof record !== "object") return undefined;
+  const r = record as Record<string, unknown>;
+  const num = (v: unknown): number | undefined =>
+    typeof v === "number" && Number.isFinite(v) ? v : undefined;
+  const usage: TurnUsage = {
+    inputTokens: num(r.inputTokens),
+    outputTokens: num(r.outputTokens),
+    cachedTokens: num(r.cachedTokens ?? r.cachedInputTokens),
+    cachedInputTokens: num(r.cachedInputTokens ?? r.cachedTokens),
+    contextUsedTokens: num(r.contextWindowUsedTokens ?? r.contextUsedTokens),
+    contextMaxTokens: num(r.contextWindowMaxTokens ?? r.contextMaxTokens),
+    costUsd: num(r.totalCostUsd ?? r.costUsd),
+  };
+  if (
+    usage.inputTokens === undefined &&
+    usage.outputTokens === undefined &&
+    usage.cachedTokens === undefined &&
+    usage.contextUsedTokens === undefined &&
+    usage.contextMaxTokens === undefined &&
+    usage.costUsd === undefined
+  ) {
+    return undefined;
+  }
+  return usage;
+}
+
+/**
+ * Lifetime turn count for an agent: one turn per user message in the full
+ * timeline history the daemon hands us on turn_ended. All outcomes count —
+ * a failed turn still consumed context. Returns undefined when no timeline
+ * was provided so callers render a placeholder instead of a false zero.
+ */
+export function countTurns(timeline: readonly unknown[] | undefined): number | undefined {
+  if (!timeline) return undefined;
+  let count = 0;
+  for (const item of timeline) {
+    if (!item || typeof item !== "object") continue;
+    if ((item as Record<string, unknown>).type === "user_message") count++;
+  }
+  return count;
+}
+
+export function summarizeTurnTimeline(timeline: readonly unknown[]): TurnActivity {
+  let toolCalls = 0;
+  let toolErrors = 0;
+  let usage: TurnUsage | undefined;
+  for (const item of timeline) {
+    if (!item || typeof item !== "object") continue;
+    const row = item as Record<string, unknown>;
+    const type = row.type;
+    if (type === "tool_call") {
+      toolCalls++;
+      const detail = row.detail as Record<string, unknown> | undefined;
+      const status = row.status ?? detail?.status;
+      if (status === "failed" || status === "error") toolErrors++;
+    }
+    if (type === "usage_updated" || type === "turn_completed") {
+      const found = readUsageRecord(
+        row.usage ?? row.detail ?? (row.detail as any)?.usage ?? (row as any).data?.usage,
+      );
+      if (found) usage = { ...usage, ...found };
+    }
+  }
+  return { toolCalls, toolErrors, usage };
+}
+
+/**
+ * A terminal event whose turnId differs from the turn that turn_started opened
+ * cannot be that turn's end: on interrupt the daemon's rescue path emits an
+ * extra terminal after the real one, sometimes with no turnId at all. Providers
+ * that never tag turns (codex/pi) keep a null id, so null-over-null is not
+ * stale.
+ */
+export function isStaleTurnEnd(
+  activeTurnId: string | null | undefined,
+  eventTurnId: string | null,
+): boolean {
+  return activeTurnId != null && eventTurnId !== activeTurnId;
+}
+
+/** Upper bound on how long after a cancel the daemon's echo can still land. */
+export const INTERRUPT_ECHO_WINDOW_MS = 5_000;
+
+export interface InterruptEchoInput {
+  /** Wall time the last canceled terminal was recorded, or null if none. */
+  lastCanceledAt: number | null;
+  /** Lifetime user_message count seen on that canceled terminal's timeline. */
+  lastCanceledUserMessages: number | null;
+  /** Lifetime user_message count on the terminal under test. */
+  eventUserMessages: number;
+  now: number;
+}
+
+/**
+ * On interrupt the daemon/provider emits a second terminal for the turn the
+ * cancel already ended — typically a 0-duration `turn_completed` reusing a
+ * freshly minted turnId, or a `turn_canceled` with no turnId. It carries no new
+ * user message, so matching the timeline's user_message count against the
+ * cancel's identifies it as the same interrupt rather than a real follow-up.
+ */
+export function isInterruptEcho(input: InterruptEchoInput): boolean {
+  if (input.lastCanceledAt == null || input.lastCanceledUserMessages == null) return false;
+  if (input.now - input.lastCanceledAt > INTERRUPT_ECHO_WINDOW_MS) return false;
+  return input.eventUserMessages <= input.lastCanceledUserMessages;
+}
+
+let lastTurnTelemetry: TopTimelineTelemetryData | null = null;
+
+let lastLiveUsage: LiveUsage | null = null;
+
+export function getLastTurnTelemetry(): TopTimelineTelemetryData | null {
+  return lastTurnTelemetry;
+}
+
+export function setLastLiveUsage(usage: LiveUsage | null): void {
+  if (usage) {
+    lastLiveUsage = { ...(lastLiveUsage ?? {}), ...usage };
+  }
+}
+
+export function getLastLiveUsage(): LiveUsage | null {
+  return lastLiveUsage;
+}
+
+export async function collectTurnTelemetry(
+  turnId: string | null,
+  agentId: string,
+  outcome: {
+    kind: "completed" | "failed" | "canceled";
+    error?: { message: string; code?: string };
+    reason?: string;
+  },
+  durationMs?: number,
+  extra?: {
+    cwd?: string | null;
+    provider?: string | null;
+    title?: string | null;
+    model?: string | null;
+    timeline?: readonly unknown[];
+    gitBefore?: GitDiffStat | null;
+    mcpRunning?: boolean;
+    mcpInstalled?: boolean;
+    mcpStorage?: Pick<PluginStorage<McpStatusSnapshot>, "exists" | "readAsync">;
+    liveUsage?: LiveUsage | null;
+  },
+): Promise<TopTimelineTelemetryData> {
+  const metrics = getSystemMetrics();
+  let totalMem = metrics.memory.totalBytes;
+  let usedMem = metrics.memory.usedBytes;
+  let memPercent = Math.round(metrics.memory.usedPercent);
+
+  if (process.platform === "linux") {
+    try {
+      const meminfo = await fs.promises.readFile("/proc/meminfo", "utf8");
+      const match = meminfo.match(/MemAvailable:\s+(\d+)\s+kB/);
+      if (match && match[1]) {
+        const available = parseInt(match[1], 10) * 1024;
+        usedMem = Math.max(0, totalMem - available);
+        memPercent = Math.round((usedMem / totalMem) * 100);
+      }
+    } catch {
+      // Fallback to metrics.memory
+    }
+  }
+
+  const loadAvg = os.loadavg();
+  const loadAvg1m = loadAvg.length > 0 ? Math.round(loadAvg[0] * 100) / 100 : 0;
+
+  let mcpHealthy: number | undefined;
+  let mcpTotal: number | undefined;
+  // Gate on live plugin state, not just the snapshot file: after mcp-tools
+  // is removed its status.json stays on disk and would otherwise bake stale
+  // counts into every new timeline item. Same check as the live RPC path.
+  const cachedMcp = extra?.mcpRunning === undefined ? await getMcpPluginState() : null;
+  const mcpRunning = extra?.mcpRunning ?? cachedMcp?.running ?? false;
+  const mcpInstalled = extra?.mcpInstalled ?? cachedMcp?.installed ?? false;
+  const mcpSnapshotSource = extra?.mcpStorage ?? mcpStorage;
+  if (mcpRunning && mcpSnapshotSource.exists()) {
+    try {
+      const snap = await mcpSnapshotSource.readAsync();
+      if (snap && typeof snap.total === "number") {
+        mcpTotal = snap.total;
+        mcpHealthy = snap.healthy;
+      }
+    } catch {
+      // Ignore
+    }
+  }
+
+  let outcomeError: string | undefined;
+  if (outcome.kind === "failed" && outcome.error) {
+    outcomeError = outcome.error.message;
+  } else if (outcome.kind === "canceled" && outcome.reason) {
+    outcomeError = outcome.reason;
+  }
+
+  const cwd = extra?.cwd ?? null;
+  const branch = await resolveGitBranch(cwd);
+  const uptimeSeconds = Math.floor(os.uptime());
+
+  let gitInsertions: number | undefined;
+  let gitDeletions: number | undefined;
+  let gitFilesChanged: number | undefined;
+  if (cwd) {
+    const before = extra?.gitBefore ?? null;
+    const after = await collectGitDiffStat(cwd);
+    if (after) {
+      gitInsertions = Math.max(0, after.insertions - (before?.insertions ?? 0));
+      gitDeletions = Math.max(0, after.deletions - (before?.deletions ?? 0));
+      gitFilesChanged = after.filesChanged;
+    }
+  }
+
+  let toolCalls: number | undefined;
+  let toolErrors: number | undefined;
+  let turnCount: number | undefined;
+  let inputTokens: number | undefined;
+  let outputTokens: number | undefined;
+  let cachedTokens: number | undefined;
+  let contextUsedTokens: number | undefined;
+  let contextMaxTokens: number | undefined;
+  let costUsd: number | undefined;
+  if (extra?.timeline) {
+    const activity = summarizeTurnTimeline(extra.timeline);
+    toolCalls = activity.toolCalls;
+    toolErrors = activity.toolErrors;
+    turnCount = countTurns(extra.timeline);
+    inputTokens = activity.usage?.inputTokens;
+    outputTokens = activity.usage?.outputTokens;
+    cachedTokens = activity.usage?.cachedTokens ?? activity.usage?.cachedInputTokens;
+    contextUsedTokens = activity.usage?.contextUsedTokens;
+    contextMaxTokens = activity.usage?.contextMaxTokens;
+    costUsd = activity.usage?.costUsd;
+  }
+
+  // Fall back to per-turn liveUsage, then lastLiveUsage, if timeline omitted tokens
+  const effectiveLiveUsage = extra?.liveUsage ?? lastLiveUsage;
+  if (inputTokens === undefined && effectiveLiveUsage?.inputTokens !== undefined) {
+    inputTokens = effectiveLiveUsage.inputTokens;
+  }
+  if (outputTokens === undefined && effectiveLiveUsage?.outputTokens !== undefined) {
+    outputTokens = effectiveLiveUsage.outputTokens;
+  }
+  if (cachedTokens === undefined && effectiveLiveUsage?.cachedInputTokens !== undefined) {
+    cachedTokens = effectiveLiveUsage.cachedInputTokens;
+  }
+  if (contextUsedTokens === undefined && effectiveLiveUsage?.contextWindowUsedTokens !== undefined) {
+    contextUsedTokens = effectiveLiveUsage.contextWindowUsedTokens;
+  }
+  if (contextMaxTokens === undefined && effectiveLiveUsage?.contextWindowMaxTokens !== undefined) {
+    contextMaxTokens = effectiveLiveUsage.contextWindowMaxTokens;
+  }
+  if (costUsd === undefined && effectiveLiveUsage?.totalCostUsd !== undefined) {
+    costUsd = effectiveLiveUsage.totalCostUsd;
+  }
+
+  const data: TopTimelineTelemetryData = {
+    turnId,
+    agentId,
+    outcomeKind: outcome.kind,
+    outcomeError,
+    timestamp: new Date().toISOString(),
+    durationMs,
+    cpuPercent: Math.round(metrics.cpu.usagePercent),
+    memUsedBytes: usedMem,
+    memTotalBytes: totalMem,
+    memPercent,
+    loadAvg1m,
+    mcpHealthy,
+    mcpTotal,
+    mcpInstalled,
+    mcpRunning,
+    branch,
+    worktree: cwd,
+    agentTitle: extra?.title ?? null,
+    agentModel: extra?.model ?? null,
+    agentProvider: extra?.provider ?? null,
+    uptimeSeconds,
+    gitInsertions,
+    gitDeletions,
+    gitFilesChanged,
+    toolCalls,
+    toolErrors,
+    turnCount,
+    inputTokens,
+    outputTokens,
+    cachedTokens,
+    cachedInputTokens: cachedTokens,
+    contextUsedTokens,
+    contextMaxTokens,
+    costUsd,
+  };
+  lastTurnTelemetry = data;
+  return data;
+}